Commit | Line | Data |
---|---|---|
2a13877c JG |
1 | |
2 | /* | |
3 | osdblk.c -- Export a single SCSI OSD object as a Linux block device | |
4 | ||
5 | ||
6 | Copyright 2009 Red Hat, Inc. | |
7 | ||
8 | This program is free software; you can redistribute it and/or modify | |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; see the file COPYING. If not, write to | |
19 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
20 | ||
21 | ||
22 | Instructions for use | |
23 | -------------------- | |
24 | ||
25 | 1) Map a Linux block device to an existing OSD object. | |
26 | ||
27 | In this example, we will use partition id 1234, object id 5678, | |
28 | OSD device /dev/osd1. | |
29 | ||
30 | $ echo "1234 5678 /dev/osd1" > /sys/class/osdblk/add | |
31 | ||
32 | ||
33 | 2) List all active blkdev<->object mappings. | |
34 | ||
35 | In this example, we have performed step #1 twice, creating two blkdevs, | |
36 | mapped to two separate OSD objects. | |
37 | ||
38 | $ cat /sys/class/osdblk/list | |
39 | 0 174 1234 5678 /dev/osd1 | |
40 | 1 179 1994 897123 /dev/osd0 | |
41 | ||
42 | The columns, in order, are: | |
43 | - blkdev unique id | |
44 | - blkdev assigned major | |
45 | - OSD object partition id | |
46 | - OSD object id | |
47 | - OSD device | |
48 | ||
49 | ||
50 | 3) Remove an active blkdev<->object mapping. | |
51 | ||
52 | In this example, we remove the mapping with blkdev unique id 1. | |
53 | ||
54 | $ echo 1 > /sys/class/osdblk/remove | |
55 | ||
56 | ||
57 | NOTE: The actual creation and deletion of OSD objects is outside the scope | |
58 | of this driver. | |
59 | ||
60 | */ | |
61 | ||
62 | #include <linux/kernel.h> | |
63 | #include <linux/device.h> | |
64 | #include <linux/module.h> | |
65 | #include <linux/fs.h> | |
66 | #include <scsi/osd_initiator.h> | |
67 | #include <scsi/osd_attributes.h> | |
68 | #include <scsi/osd_sec.h> | |
bc47df0f | 69 | #include <scsi/scsi_device.h> |
2a13877c JG |
70 | |
71 | #define DRV_NAME "osdblk" | |
72 | #define PFX DRV_NAME ": " | |
73 | ||
74 | /* #define _OSDBLK_DEBUG */ | |
75 | #ifdef _OSDBLK_DEBUG | |
76 | #define OSDBLK_DEBUG(fmt, a...) \ | |
77 | printk(KERN_NOTICE "osdblk @%s:%d: " fmt, __func__, __LINE__, ##a) | |
78 | #else | |
79 | #define OSDBLK_DEBUG(fmt, a...) \ | |
80 | do { if (0) printk(fmt, ##a); } while (0) | |
81 | #endif | |
82 | ||
83 | MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>"); | |
84 | MODULE_DESCRIPTION("block device inside an OSD object osdblk.ko"); | |
85 | MODULE_LICENSE("GPL"); | |
86 | ||
87 | struct osdblk_device; | |
88 | ||
89 | enum { | |
90 | OSDBLK_MINORS_PER_MAJOR = 256, /* max minors per blkdev */ | |
91 | OSDBLK_MAX_REQ = 32, /* max parallel requests */ | |
92 | OSDBLK_OP_TIMEOUT = 4 * 60, /* sync OSD req timeout */ | |
93 | }; | |
94 | ||
95 | struct osdblk_request { | |
96 | struct request *rq; /* blk layer request */ | |
97 | struct bio *bio; /* cloned bio */ | |
98 | struct osdblk_device *osdev; /* associated blkdev */ | |
99 | }; | |
100 | ||
101 | struct osdblk_device { | |
102 | int id; /* blkdev unique id */ | |
103 | ||
104 | int major; /* blkdev assigned major */ | |
105 | struct gendisk *disk; /* blkdev's gendisk and rq */ | |
106 | struct request_queue *q; | |
107 | ||
108 | struct osd_dev *osd; /* associated OSD */ | |
109 | ||
110 | char name[32]; /* blkdev name, e.g. osdblk34 */ | |
111 | ||
112 | spinlock_t lock; /* queue lock */ | |
113 | ||
114 | struct osd_obj_id obj; /* OSD partition, obj id */ | |
115 | uint8_t obj_cred[OSD_CAP_LEN]; /* OSD cred */ | |
116 | ||
117 | struct osdblk_request req[OSDBLK_MAX_REQ]; /* request table */ | |
118 | ||
119 | struct list_head node; | |
120 | ||
121 | char osd_path[0]; /* OSD device path */ | |
122 | }; | |
123 | ||
124 | static struct class *class_osdblk; /* /sys/class/osdblk */ | |
125 | static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */ | |
126 | static LIST_HEAD(osdblkdev_list); | |
127 | ||
83d5cde4 | 128 | static const struct block_device_operations osdblk_bd_ops = { |
2a13877c JG |
129 | .owner = THIS_MODULE, |
130 | }; | |
131 | ||
132 | static const struct osd_attr g_attr_logical_length = ATTR_DEF( | |
133 | OSD_APAGE_OBJECT_INFORMATION, OSD_ATTR_OI_LOGICAL_LENGTH, 8); | |
134 | ||
135 | static void osdblk_make_credential(u8 cred_a[OSD_CAP_LEN], | |
136 | const struct osd_obj_id *obj) | |
137 | { | |
138 | osd_sec_init_nosec_doall_caps(cred_a, obj, false, true); | |
139 | } | |
140 | ||
141 | /* copied from exofs; move to libosd? */ | |
142 | /* | |
143 | * Perform a synchronous OSD operation. copied from exofs; move to libosd? | |
144 | */ | |
145 | static int osd_sync_op(struct osd_request *or, int timeout, uint8_t *credential) | |
146 | { | |
147 | int ret; | |
148 | ||
149 | or->timeout = timeout; | |
150 | ret = osd_finalize_request(or, 0, credential, NULL); | |
151 | if (ret) | |
152 | return ret; | |
153 | ||
154 | ret = osd_execute_request(or); | |
155 | ||
156 | /* osd_req_decode_sense(or, ret); */ | |
157 | return ret; | |
158 | } | |
159 | ||
160 | /* | |
161 | * Perform an asynchronous OSD operation. copied from exofs; move to libosd? | |
162 | */ | |
163 | static int osd_async_op(struct osd_request *or, osd_req_done_fn *async_done, | |
164 | void *caller_context, u8 *cred) | |
165 | { | |
166 | int ret; | |
167 | ||
168 | ret = osd_finalize_request(or, 0, cred, NULL); | |
169 | if (ret) | |
170 | return ret; | |
171 | ||
172 | ret = osd_execute_request_async(or, async_done, caller_context); | |
173 | ||
174 | return ret; | |
175 | } | |
176 | ||
177 | /* copied from exofs; move to libosd? */ | |
178 | static int extract_attr_from_req(struct osd_request *or, struct osd_attr *attr) | |
179 | { | |
180 | struct osd_attr cur_attr = {.attr_page = 0}; /* start with zeros */ | |
181 | void *iter = NULL; | |
182 | int nelem; | |
183 | ||
184 | do { | |
185 | nelem = 1; | |
186 | osd_req_decode_get_attr_list(or, &cur_attr, &nelem, &iter); | |
187 | if ((cur_attr.attr_page == attr->attr_page) && | |
188 | (cur_attr.attr_id == attr->attr_id)) { | |
189 | attr->len = cur_attr.len; | |
190 | attr->val_ptr = cur_attr.val_ptr; | |
191 | return 0; | |
192 | } | |
193 | } while (iter); | |
194 | ||
195 | return -EIO; | |
196 | } | |
197 | ||
198 | static int osdblk_get_obj_size(struct osdblk_device *osdev, u64 *size_out) | |
199 | { | |
200 | struct osd_request *or; | |
201 | struct osd_attr attr; | |
202 | int ret; | |
203 | ||
204 | /* start request */ | |
205 | or = osd_start_request(osdev->osd, GFP_KERNEL); | |
206 | if (!or) | |
207 | return -ENOMEM; | |
208 | ||
209 | /* create a get-attributes(length) request */ | |
210 | osd_req_get_attributes(or, &osdev->obj); | |
211 | ||
212 | osd_req_add_get_attr_list(or, &g_attr_logical_length, 1); | |
213 | ||
214 | /* execute op synchronously */ | |
215 | ret = osd_sync_op(or, OSDBLK_OP_TIMEOUT, osdev->obj_cred); | |
216 | if (ret) | |
217 | goto out; | |
218 | ||
219 | /* extract length from returned attribute info */ | |
220 | attr = g_attr_logical_length; | |
221 | ret = extract_attr_from_req(or, &attr); | |
222 | if (ret) | |
223 | goto out; | |
224 | ||
225 | *size_out = get_unaligned_be64(attr.val_ptr); | |
226 | ||
227 | out: | |
228 | osd_end_request(or); | |
229 | return ret; | |
230 | ||
231 | } | |
232 | ||
233 | static void osdblk_osd_complete(struct osd_request *or, void *private) | |
234 | { | |
235 | struct osdblk_request *orq = private; | |
236 | struct osd_sense_info osi; | |
237 | int ret = osd_req_decode_sense(or, &osi); | |
238 | ||
239 | if (ret) { | |
240 | ret = -EIO; | |
241 | OSDBLK_DEBUG("osdblk_osd_complete with err=%d\n", ret); | |
242 | } | |
243 | ||
244 | /* complete OSD request */ | |
245 | osd_end_request(or); | |
246 | ||
247 | /* complete request passed to osdblk by block layer */ | |
248 | __blk_end_request_all(orq->rq, ret); | |
249 | } | |
250 | ||
251 | static void bio_chain_put(struct bio *chain) | |
252 | { | |
253 | struct bio *tmp; | |
254 | ||
255 | while (chain) { | |
256 | tmp = chain; | |
257 | chain = chain->bi_next; | |
258 | ||
259 | bio_put(tmp); | |
260 | } | |
261 | } | |
262 | ||
263 | static struct bio *bio_chain_clone(struct bio *old_chain, gfp_t gfpmask) | |
264 | { | |
265 | struct bio *tmp, *new_chain = NULL, *tail = NULL; | |
266 | ||
267 | while (old_chain) { | |
268 | tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs); | |
269 | if (!tmp) | |
270 | goto err_out; | |
271 | ||
272 | __bio_clone(tmp, old_chain); | |
273 | tmp->bi_bdev = NULL; | |
274 | gfpmask &= ~__GFP_WAIT; | |
275 | tmp->bi_next = NULL; | |
276 | ||
277 | if (!new_chain) | |
278 | new_chain = tail = tmp; | |
279 | else { | |
280 | tail->bi_next = tmp; | |
281 | tail = tmp; | |
282 | } | |
283 | ||
284 | old_chain = old_chain->bi_next; | |
285 | } | |
286 | ||
287 | return new_chain; | |
288 | ||
289 | err_out: | |
290 | OSDBLK_DEBUG("bio_chain_clone with err\n"); | |
291 | bio_chain_put(new_chain); | |
292 | return NULL; | |
293 | } | |
294 | ||
295 | static void osdblk_rq_fn(struct request_queue *q) | |
296 | { | |
297 | struct osdblk_device *osdev = q->queuedata; | |
298 | ||
299 | while (1) { | |
300 | struct request *rq; | |
301 | struct osdblk_request *orq; | |
302 | struct osd_request *or; | |
303 | struct bio *bio; | |
304 | bool do_write, do_flush; | |
305 | ||
306 | /* peek at request from block layer */ | |
307 | rq = blk_fetch_request(q); | |
308 | if (!rq) | |
309 | break; | |
310 | ||
311 | /* filter out block requests we don't understand */ | |
312 | if (!blk_fs_request(rq) && !blk_barrier_rq(rq)) { | |
313 | blk_end_request_all(rq, 0); | |
314 | continue; | |
315 | } | |
316 | ||
317 | /* deduce our operation (read, write, flush) */ | |
318 | /* I wish the block layer simplified cmd_type/cmd_flags/cmd[] | |
319 | * into a clearly defined set of RPC commands: | |
320 | * read, write, flush, scsi command, power mgmt req, | |
321 | * driver-specific, etc. | |
322 | */ | |
323 | ||
324 | do_flush = (rq->special == (void *) 0xdeadbeefUL); | |
325 | do_write = (rq_data_dir(rq) == WRITE); | |
326 | ||
327 | if (!do_flush) { /* osd_flush does not use a bio */ | |
328 | /* a bio clone to be passed down to OSD request */ | |
329 | bio = bio_chain_clone(rq->bio, GFP_ATOMIC); | |
330 | if (!bio) | |
331 | break; | |
332 | } else | |
333 | bio = NULL; | |
334 | ||
335 | /* alloc internal OSD request, for OSD command execution */ | |
336 | or = osd_start_request(osdev->osd, GFP_ATOMIC); | |
337 | if (!or) { | |
338 | bio_chain_put(bio); | |
339 | OSDBLK_DEBUG("osd_start_request with err\n"); | |
340 | break; | |
341 | } | |
342 | ||
343 | orq = &osdev->req[rq->tag]; | |
344 | orq->rq = rq; | |
345 | orq->bio = bio; | |
346 | orq->osdev = osdev; | |
347 | ||
348 | /* init OSD command: flush, write or read */ | |
349 | if (do_flush) | |
350 | osd_req_flush_object(or, &osdev->obj, | |
351 | OSD_CDB_FLUSH_ALL, 0, 0); | |
352 | else if (do_write) | |
353 | osd_req_write(or, &osdev->obj, blk_rq_pos(rq) * 512ULL, | |
354 | bio, blk_rq_bytes(rq)); | |
355 | else | |
356 | osd_req_read(or, &osdev->obj, blk_rq_pos(rq) * 512ULL, | |
357 | bio, blk_rq_bytes(rq)); | |
358 | ||
359 | OSDBLK_DEBUG("%s 0x%x bytes at 0x%llx\n", | |
360 | do_flush ? "flush" : do_write ? | |
361 | "write" : "read", blk_rq_bytes(rq), | |
362 | blk_rq_pos(rq) * 512ULL); | |
363 | ||
364 | /* begin OSD command execution */ | |
365 | if (osd_async_op(or, osdblk_osd_complete, orq, | |
366 | osdev->obj_cred)) { | |
367 | osd_end_request(or); | |
368 | blk_requeue_request(q, rq); | |
369 | bio_chain_put(bio); | |
370 | OSDBLK_DEBUG("osd_execute_request_async with err\n"); | |
371 | break; | |
372 | } | |
373 | ||
374 | /* remove the special 'flush' marker, now that the command | |
375 | * is executing | |
376 | */ | |
377 | rq->special = NULL; | |
378 | } | |
379 | } | |
380 | ||
381 | static void osdblk_prepare_flush(struct request_queue *q, struct request *rq) | |
382 | { | |
383 | /* add driver-specific marker, to indicate that this request | |
384 | * is a flush command | |
385 | */ | |
386 | rq->special = (void *) 0xdeadbeefUL; | |
387 | } | |
388 | ||
389 | static void osdblk_free_disk(struct osdblk_device *osdev) | |
390 | { | |
391 | struct gendisk *disk = osdev->disk; | |
392 | ||
393 | if (!disk) | |
394 | return; | |
395 | ||
396 | if (disk->flags & GENHD_FL_UP) | |
397 | del_gendisk(disk); | |
398 | if (disk->queue) | |
399 | blk_cleanup_queue(disk->queue); | |
400 | put_disk(disk); | |
401 | } | |
402 | ||
403 | static int osdblk_init_disk(struct osdblk_device *osdev) | |
404 | { | |
405 | struct gendisk *disk; | |
406 | struct request_queue *q; | |
407 | int rc; | |
408 | u64 obj_size = 0; | |
409 | ||
410 | /* contact OSD, request size info about the object being mapped */ | |
411 | rc = osdblk_get_obj_size(osdev, &obj_size); | |
412 | if (rc) | |
413 | return rc; | |
414 | ||
415 | /* create gendisk info */ | |
416 | disk = alloc_disk(OSDBLK_MINORS_PER_MAJOR); | |
417 | if (!disk) | |
418 | return -ENOMEM; | |
419 | ||
420 | sprintf(disk->disk_name, DRV_NAME "%d", osdev->id); | |
421 | disk->major = osdev->major; | |
422 | disk->first_minor = 0; | |
423 | disk->fops = &osdblk_bd_ops; | |
424 | disk->private_data = osdev; | |
425 | ||
426 | /* init rq */ | |
427 | q = blk_init_queue(osdblk_rq_fn, &osdev->lock); | |
428 | if (!q) { | |
429 | put_disk(disk); | |
430 | return -ENOMEM; | |
431 | } | |
432 | ||
433 | /* switch queue to TCQ mode; allocate tag map */ | |
434 | rc = blk_queue_init_tags(q, OSDBLK_MAX_REQ, NULL); | |
435 | if (rc) { | |
436 | blk_cleanup_queue(q); | |
437 | put_disk(disk); | |
438 | return rc; | |
439 | } | |
440 | ||
bc47df0f BH |
441 | /* Set our limits to the lower device limits, because osdblk cannot |
442 | * sleep when allocating a lower-request and therefore cannot be | |
443 | * bouncing. | |
444 | */ | |
445 | blk_queue_stack_limits(q, osd_request_queue(osdev->osd)); | |
446 | ||
2a13877c JG |
447 | blk_queue_prep_rq(q, blk_queue_start_tag); |
448 | blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH, osdblk_prepare_flush); | |
449 | ||
450 | disk->queue = q; | |
451 | ||
452 | q->queuedata = osdev; | |
453 | ||
454 | osdev->disk = disk; | |
455 | osdev->q = q; | |
456 | ||
457 | /* finally, announce the disk to the world */ | |
458 | set_capacity(disk, obj_size / 512ULL); | |
459 | add_disk(disk); | |
460 | ||
461 | printk(KERN_INFO "%s: Added of size 0x%llx\n", | |
462 | disk->disk_name, (unsigned long long)obj_size); | |
463 | ||
464 | return 0; | |
465 | } | |
466 | ||
467 | /******************************************************************** | |
468 | * /sys/class/osdblk/ | |
469 | * add map OSD object to blkdev | |
470 | * remove unmap OSD object | |
471 | * list show mappings | |
472 | *******************************************************************/ | |
473 | ||
474 | static void class_osdblk_release(struct class *cls) | |
475 | { | |
476 | kfree(cls); | |
477 | } | |
478 | ||
28812fe1 AK |
479 | static ssize_t class_osdblk_list(struct class *c, |
480 | struct class_attribute *attr, | |
481 | char *data) | |
2a13877c JG |
482 | { |
483 | int n = 0; | |
484 | struct list_head *tmp; | |
485 | ||
486 | mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); | |
487 | ||
488 | list_for_each(tmp, &osdblkdev_list) { | |
489 | struct osdblk_device *osdev; | |
490 | ||
491 | osdev = list_entry(tmp, struct osdblk_device, node); | |
492 | ||
493 | n += sprintf(data+n, "%d %d %llu %llu %s\n", | |
494 | osdev->id, | |
495 | osdev->major, | |
496 | osdev->obj.partition, | |
497 | osdev->obj.id, | |
498 | osdev->osd_path); | |
499 | } | |
500 | ||
501 | mutex_unlock(&ctl_mutex); | |
502 | return n; | |
503 | } | |
504 | ||
28812fe1 AK |
505 | static ssize_t class_osdblk_add(struct class *c, |
506 | struct class_attribute *attr, | |
507 | const char *buf, size_t count) | |
2a13877c JG |
508 | { |
509 | struct osdblk_device *osdev; | |
510 | ssize_t rc; | |
511 | int irc, new_id = 0; | |
512 | struct list_head *tmp; | |
513 | ||
514 | if (!try_module_get(THIS_MODULE)) | |
515 | return -ENODEV; | |
516 | ||
517 | /* new osdblk_device object */ | |
518 | osdev = kzalloc(sizeof(*osdev) + strlen(buf) + 1, GFP_KERNEL); | |
519 | if (!osdev) { | |
520 | rc = -ENOMEM; | |
521 | goto err_out_mod; | |
522 | } | |
523 | ||
524 | /* static osdblk_device initialization */ | |
525 | spin_lock_init(&osdev->lock); | |
526 | INIT_LIST_HEAD(&osdev->node); | |
527 | ||
528 | /* generate unique id: find highest unique id, add one */ | |
529 | ||
530 | mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); | |
531 | ||
532 | list_for_each(tmp, &osdblkdev_list) { | |
533 | struct osdblk_device *osdev; | |
534 | ||
535 | osdev = list_entry(tmp, struct osdblk_device, node); | |
536 | if (osdev->id > new_id) | |
537 | new_id = osdev->id + 1; | |
538 | } | |
539 | ||
540 | osdev->id = new_id; | |
541 | ||
542 | /* add to global list */ | |
543 | list_add_tail(&osdev->node, &osdblkdev_list); | |
544 | ||
545 | mutex_unlock(&ctl_mutex); | |
546 | ||
547 | /* parse add command */ | |
548 | if (sscanf(buf, "%llu %llu %s", &osdev->obj.partition, &osdev->obj.id, | |
549 | osdev->osd_path) != 3) { | |
550 | rc = -EINVAL; | |
551 | goto err_out_slot; | |
552 | } | |
553 | ||
554 | /* initialize rest of new object */ | |
555 | sprintf(osdev->name, DRV_NAME "%d", osdev->id); | |
556 | ||
557 | /* contact requested OSD */ | |
558 | osdev->osd = osduld_path_lookup(osdev->osd_path); | |
559 | if (IS_ERR(osdev->osd)) { | |
560 | rc = PTR_ERR(osdev->osd); | |
561 | goto err_out_slot; | |
562 | } | |
563 | ||
564 | /* build OSD credential */ | |
565 | osdblk_make_credential(osdev->obj_cred, &osdev->obj); | |
566 | ||
567 | /* register our block device */ | |
568 | irc = register_blkdev(0, osdev->name); | |
569 | if (irc < 0) { | |
570 | rc = irc; | |
571 | goto err_out_osd; | |
572 | } | |
573 | ||
574 | osdev->major = irc; | |
575 | ||
576 | /* set up and announce blkdev mapping */ | |
577 | rc = osdblk_init_disk(osdev); | |
578 | if (rc) | |
579 | goto err_out_blkdev; | |
580 | ||
581 | return count; | |
582 | ||
583 | err_out_blkdev: | |
584 | unregister_blkdev(osdev->major, osdev->name); | |
585 | err_out_osd: | |
586 | osduld_put_device(osdev->osd); | |
587 | err_out_slot: | |
588 | mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); | |
589 | list_del_init(&osdev->node); | |
590 | mutex_unlock(&ctl_mutex); | |
591 | ||
592 | kfree(osdev); | |
593 | err_out_mod: | |
594 | OSDBLK_DEBUG("Error adding device %s\n", buf); | |
595 | module_put(THIS_MODULE); | |
596 | return rc; | |
597 | } | |
598 | ||
28812fe1 AK |
599 | static ssize_t class_osdblk_remove(struct class *c, |
600 | struct class_attribute *attr, | |
601 | const char *buf, | |
2a13877c JG |
602 | size_t count) |
603 | { | |
604 | struct osdblk_device *osdev = NULL; | |
605 | int target_id, rc; | |
606 | unsigned long ul; | |
607 | struct list_head *tmp; | |
608 | ||
609 | rc = strict_strtoul(buf, 10, &ul); | |
610 | if (rc) | |
611 | return rc; | |
612 | ||
613 | /* convert to int; abort if we lost anything in the conversion */ | |
614 | target_id = (int) ul; | |
615 | if (target_id != ul) | |
616 | return -EINVAL; | |
617 | ||
618 | /* remove object from list immediately */ | |
619 | mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); | |
620 | ||
621 | list_for_each(tmp, &osdblkdev_list) { | |
622 | osdev = list_entry(tmp, struct osdblk_device, node); | |
623 | if (osdev->id == target_id) { | |
624 | list_del_init(&osdev->node); | |
625 | break; | |
626 | } | |
627 | osdev = NULL; | |
628 | } | |
629 | ||
630 | mutex_unlock(&ctl_mutex); | |
631 | ||
632 | if (!osdev) | |
633 | return -ENOENT; | |
634 | ||
635 | /* clean up and free blkdev and associated OSD connection */ | |
636 | osdblk_free_disk(osdev); | |
637 | unregister_blkdev(osdev->major, osdev->name); | |
638 | osduld_put_device(osdev->osd); | |
639 | kfree(osdev); | |
640 | ||
641 | /* release module ref */ | |
642 | module_put(THIS_MODULE); | |
643 | ||
644 | return count; | |
645 | } | |
646 | ||
647 | static struct class_attribute class_osdblk_attrs[] = { | |
648 | __ATTR(add, 0200, NULL, class_osdblk_add), | |
649 | __ATTR(remove, 0200, NULL, class_osdblk_remove), | |
650 | __ATTR(list, 0444, class_osdblk_list, NULL), | |
651 | __ATTR_NULL | |
652 | }; | |
653 | ||
654 | static int osdblk_sysfs_init(void) | |
655 | { | |
656 | int ret = 0; | |
657 | ||
658 | /* | |
659 | * create control files in sysfs | |
660 | * /sys/class/osdblk/... | |
661 | */ | |
662 | class_osdblk = kzalloc(sizeof(*class_osdblk), GFP_KERNEL); | |
663 | if (!class_osdblk) | |
664 | return -ENOMEM; | |
665 | ||
666 | class_osdblk->name = DRV_NAME; | |
667 | class_osdblk->owner = THIS_MODULE; | |
668 | class_osdblk->class_release = class_osdblk_release; | |
669 | class_osdblk->class_attrs = class_osdblk_attrs; | |
670 | ||
671 | ret = class_register(class_osdblk); | |
672 | if (ret) { | |
673 | kfree(class_osdblk); | |
674 | class_osdblk = NULL; | |
675 | printk(PFX "failed to create class osdblk\n"); | |
676 | return ret; | |
677 | } | |
678 | ||
679 | return 0; | |
680 | } | |
681 | ||
682 | static void osdblk_sysfs_cleanup(void) | |
683 | { | |
684 | if (class_osdblk) | |
685 | class_destroy(class_osdblk); | |
686 | class_osdblk = NULL; | |
687 | } | |
688 | ||
689 | static int __init osdblk_init(void) | |
690 | { | |
691 | int rc; | |
692 | ||
693 | rc = osdblk_sysfs_init(); | |
694 | if (rc) | |
695 | return rc; | |
696 | ||
697 | return 0; | |
698 | } | |
699 | ||
700 | static void __exit osdblk_exit(void) | |
701 | { | |
702 | osdblk_sysfs_cleanup(); | |
703 | } | |
704 | ||
705 | module_init(osdblk_init); | |
706 | module_exit(osdblk_exit); | |
707 |