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