[S390] dcss: fix build bug.
[linux-3.10.git] / drivers / s390 / block / dcssblk.c
1 /*
2  * dcssblk.c -- the S/390 block driver for dcss memory
3  *
4  * Authors: Carsten Otte, Stefan Weinhuber, Gerald Schaefer
5  */
6
7 #include <linux/module.h>
8 #include <linux/moduleparam.h>
9 #include <linux/ctype.h>
10 #include <linux/errno.h>
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <linux/blkdev.h>
14 #include <asm/extmem.h>
15 #include <asm/io.h>
16 #include <linux/completion.h>
17 #include <linux/interrupt.h>
18 #include <asm/s390_rdev.h>
19
20 //#define DCSSBLK_DEBUG         /* Debug messages on/off */
21 #define DCSSBLK_NAME "dcssblk"
22 #define DCSSBLK_MINORS_PER_DISK 1
23 #define DCSSBLK_PARM_LEN 400
24
25 #ifdef DCSSBLK_DEBUG
26 #define PRINT_DEBUG(x...) printk(KERN_DEBUG DCSSBLK_NAME " debug: " x)
27 #else
28 #define PRINT_DEBUG(x...) do {} while (0)
29 #endif
30 #define PRINT_INFO(x...)  printk(KERN_INFO DCSSBLK_NAME " info: " x)
31 #define PRINT_WARN(x...)  printk(KERN_WARNING DCSSBLK_NAME " warning: " x)
32 #define PRINT_ERR(x...)   printk(KERN_ERR DCSSBLK_NAME " error: " x)
33
34
35 static int dcssblk_open(struct inode *inode, struct file *filp);
36 static int dcssblk_release(struct inode *inode, struct file *filp);
37 static int dcssblk_make_request(struct request_queue *q, struct bio *bio);
38 static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum,
39                                  void **kaddr, unsigned long *pfn);
40
41 static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0";
42
43 static int dcssblk_major;
44 static struct block_device_operations dcssblk_devops = {
45         .owner          = THIS_MODULE,
46         .open           = dcssblk_open,
47         .release        = dcssblk_release,
48         .direct_access  = dcssblk_direct_access,
49 };
50
51 static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf,
52                                   size_t count);
53 static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf,
54                                   size_t count);
55 static ssize_t dcssblk_save_store(struct device * dev, struct device_attribute *attr, const char * buf,
56                                   size_t count);
57 static ssize_t dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf);
58 static ssize_t dcssblk_shared_store(struct device * dev, struct device_attribute *attr, const char * buf,
59                                   size_t count);
60 static ssize_t dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf);
61
62 static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store);
63 static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store);
64 static DEVICE_ATTR(save, S_IWUSR | S_IRUGO, dcssblk_save_show,
65                    dcssblk_save_store);
66 static DEVICE_ATTR(shared, S_IWUSR | S_IRUGO, dcssblk_shared_show,
67                    dcssblk_shared_store);
68
69 static struct device *dcssblk_root_dev;
70
71 struct dcssblk_dev_info {
72         struct list_head lh;
73         struct device dev;
74         char segment_name[BUS_ID_SIZE];
75         atomic_t use_count;
76         struct gendisk *gd;
77         unsigned long start;
78         unsigned long end;
79         int segment_type;
80         unsigned char save_pending;
81         unsigned char is_shared;
82         struct request_queue *dcssblk_queue;
83 };
84
85 static LIST_HEAD(dcssblk_devices);
86 static struct rw_semaphore dcssblk_devices_sem;
87
88 /*
89  * release function for segment device.
90  */
91 static void
92 dcssblk_release_segment(struct device *dev)
93 {
94         PRINT_DEBUG("segment release fn called for %s\n", dev->bus_id);
95         kfree(container_of(dev, struct dcssblk_dev_info, dev));
96         module_put(THIS_MODULE);
97 }
98
99 /*
100  * get a minor number. needs to be called with
101  * down_write(&dcssblk_devices_sem) and the
102  * device needs to be enqueued before the semaphore is
103  * freed.
104  */
105 static int
106 dcssblk_assign_free_minor(struct dcssblk_dev_info *dev_info)
107 {
108         int minor, found;
109         struct dcssblk_dev_info *entry;
110
111         if (dev_info == NULL)
112                 return -EINVAL;
113         for (minor = 0; minor < (1<<MINORBITS); minor++) {
114                 found = 0;
115                 // test if minor available
116                 list_for_each_entry(entry, &dcssblk_devices, lh)
117                         if (minor == entry->gd->first_minor)
118                                 found++;
119                 if (!found) break; // got unused minor
120         }
121         if (found)
122                 return -EBUSY;
123         dev_info->gd->first_minor = minor;
124         return 0;
125 }
126
127 /*
128  * get the struct dcssblk_dev_info from dcssblk_devices
129  * for the given name.
130  * down_read(&dcssblk_devices_sem) must be held.
131  */
132 static struct dcssblk_dev_info *
133 dcssblk_get_device_by_name(char *name)
134 {
135         struct dcssblk_dev_info *entry;
136
137         list_for_each_entry(entry, &dcssblk_devices, lh) {
138                 if (!strcmp(name, entry->segment_name)) {
139                         return entry;
140                 }
141         }
142         return NULL;
143 }
144
145 static void dcssblk_unregister_callback(struct device *dev)
146 {
147         device_unregister(dev);
148         put_device(dev);
149 }
150
151 /*
152  * device attribute for switching shared/nonshared (exclusive)
153  * operation (show + store)
154  */
155 static ssize_t
156 dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
157 {
158         struct dcssblk_dev_info *dev_info;
159
160         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
161         return sprintf(buf, dev_info->is_shared ? "1\n" : "0\n");
162 }
163
164 static ssize_t
165 dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
166 {
167         struct dcssblk_dev_info *dev_info;
168         int rc;
169
170         if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
171                 return -EINVAL;
172         down_write(&dcssblk_devices_sem);
173         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
174         if (atomic_read(&dev_info->use_count)) {
175                 PRINT_ERR("share: segment %s is busy!\n",
176                           dev_info->segment_name);
177                 rc = -EBUSY;
178                 goto out;
179         }
180         if (inbuf[0] == '1') {
181                 // reload segment in shared mode
182                 rc = segment_modify_shared(dev_info->segment_name,
183                                            SEGMENT_SHARED);
184                 if (rc < 0) {
185                         BUG_ON(rc == -EINVAL);
186                         if (rc != -EAGAIN)
187                                 goto removeseg;
188                 } else {
189                         dev_info->is_shared = 1;
190                         switch (dev_info->segment_type) {
191                                 case SEG_TYPE_SR:
192                                 case SEG_TYPE_ER:
193                                 case SEG_TYPE_SC:
194                                         set_disk_ro(dev_info->gd,1);
195                         }
196                 }
197         } else if (inbuf[0] == '0') {
198                 // reload segment in exclusive mode
199                 if (dev_info->segment_type == SEG_TYPE_SC) {
200                         PRINT_ERR("Segment type SC (%s) cannot be loaded in "
201                                   "non-shared mode\n", dev_info->segment_name);
202                         rc = -EINVAL;
203                         goto out;
204                 }
205                 rc = segment_modify_shared(dev_info->segment_name,
206                                            SEGMENT_EXCLUSIVE);
207                 if (rc < 0) {
208                         BUG_ON(rc == -EINVAL);
209                         if (rc != -EAGAIN)
210                                 goto removeseg;
211                 } else {
212                         dev_info->is_shared = 0;
213                         set_disk_ro(dev_info->gd, 0);
214                 }
215         } else {
216                 rc = -EINVAL;
217                 goto out;
218         }
219         rc = count;
220         goto out;
221
222 removeseg:
223         PRINT_ERR("Could not reload segment %s, removing it now!\n",
224                         dev_info->segment_name);
225         list_del(&dev_info->lh);
226
227         del_gendisk(dev_info->gd);
228         blk_cleanup_queue(dev_info->dcssblk_queue);
229         dev_info->gd->queue = NULL;
230         put_disk(dev_info->gd);
231         rc = device_schedule_callback(dev, dcssblk_unregister_callback);
232 out:
233         up_write(&dcssblk_devices_sem);
234         return rc;
235 }
236
237 /*
238  * device attribute for save operation on current copy
239  * of the segment. If the segment is busy, saving will
240  * become pending until it gets released, which can be
241  * undone by storing a non-true value to this entry.
242  * (show + store)
243  */
244 static ssize_t
245 dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf)
246 {
247         struct dcssblk_dev_info *dev_info;
248
249         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
250         return sprintf(buf, dev_info->save_pending ? "1\n" : "0\n");
251 }
252
253 static ssize_t
254 dcssblk_save_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
255 {
256         struct dcssblk_dev_info *dev_info;
257
258         if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
259                 return -EINVAL;
260         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
261
262         down_write(&dcssblk_devices_sem);
263         if (inbuf[0] == '1') {
264                 if (atomic_read(&dev_info->use_count) == 0) {
265                         // device is idle => we save immediately
266                         PRINT_INFO("Saving segment %s\n",
267                                    dev_info->segment_name);
268                         segment_save(dev_info->segment_name);
269                 }  else {
270                         // device is busy => we save it when it becomes
271                         // idle in dcssblk_release
272                         PRINT_INFO("Segment %s is currently busy, it will "
273                                    "be saved when it becomes idle...\n",
274                                    dev_info->segment_name);
275                         dev_info->save_pending = 1;
276                 }
277         } else if (inbuf[0] == '0') {
278                 if (dev_info->save_pending) {
279                         // device is busy & the user wants to undo his save
280                         // request
281                         dev_info->save_pending = 0;
282                         PRINT_INFO("Pending save for segment %s deactivated\n",
283                                         dev_info->segment_name);
284                 }
285         } else {
286                 up_write(&dcssblk_devices_sem);
287                 return -EINVAL;
288         }
289         up_write(&dcssblk_devices_sem);
290         return count;
291 }
292
293 /*
294  * device attribute for adding devices
295  */
296 static ssize_t
297 dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
298 {
299         int rc, i;
300         struct dcssblk_dev_info *dev_info;
301         char *local_buf;
302         unsigned long seg_byte_size;
303
304         dev_info = NULL;
305         if (dev != dcssblk_root_dev) {
306                 rc = -EINVAL;
307                 goto out_nobuf;
308         }
309         local_buf = kmalloc(count + 1, GFP_KERNEL);
310         if (local_buf == NULL) {
311                 rc = -ENOMEM;
312                 goto out_nobuf;
313         }
314         /*
315          * parse input
316          */
317         for (i = 0; ((buf[i] != '\0') && (buf[i] != '\n') && i < count); i++) {
318                 local_buf[i] = toupper(buf[i]);
319         }
320         local_buf[i] = '\0';
321         if ((i == 0) || (i > 8)) {
322                 rc = -ENAMETOOLONG;
323                 goto out;
324         }
325         /*
326          * already loaded?
327          */
328         down_read(&dcssblk_devices_sem);
329         dev_info = dcssblk_get_device_by_name(local_buf);
330         up_read(&dcssblk_devices_sem);
331         if (dev_info != NULL) {
332                 PRINT_WARN("Segment %s already loaded!\n", local_buf);
333                 rc = -EEXIST;
334                 goto out;
335         }
336         /*
337          * get a struct dcssblk_dev_info
338          */
339         dev_info = kzalloc(sizeof(struct dcssblk_dev_info), GFP_KERNEL);
340         if (dev_info == NULL) {
341                 rc = -ENOMEM;
342                 goto out;
343         }
344
345         strcpy(dev_info->segment_name, local_buf);
346         strlcpy(dev_info->dev.bus_id, local_buf, BUS_ID_SIZE);
347         dev_info->dev.release = dcssblk_release_segment;
348         INIT_LIST_HEAD(&dev_info->lh);
349
350         dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK);
351         if (dev_info->gd == NULL) {
352                 rc = -ENOMEM;
353                 goto free_dev_info;
354         }
355         dev_info->gd->major = dcssblk_major;
356         dev_info->gd->fops = &dcssblk_devops;
357         dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL);
358         dev_info->gd->queue = dev_info->dcssblk_queue;
359         dev_info->gd->private_data = dev_info;
360         dev_info->gd->driverfs_dev = &dev_info->dev;
361         blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
362         blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096);
363         /*
364          * load the segment
365          */
366         rc = segment_load(local_buf, SEGMENT_SHARED,
367                                 &dev_info->start, &dev_info->end);
368         if (rc < 0) {
369                 segment_warning(rc, dev_info->segment_name);
370                 goto dealloc_gendisk;
371         }
372         seg_byte_size = (dev_info->end - dev_info->start + 1);
373         set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors
374         PRINT_INFO("Loaded segment %s, size = %lu Byte, "
375                    "capacity = %lu (512 Byte) sectors\n", local_buf,
376                    seg_byte_size, seg_byte_size >> 9);
377
378         dev_info->segment_type = rc;
379         dev_info->save_pending = 0;
380         dev_info->is_shared = 1;
381         dev_info->dev.parent = dcssblk_root_dev;
382
383         /*
384          * get minor, add to list
385          */
386         down_write(&dcssblk_devices_sem);
387         if (dcssblk_get_device_by_name(local_buf)) {
388                 up_write(&dcssblk_devices_sem);
389                 rc = -EEXIST;
390                 goto unload_seg;
391         }
392         rc = dcssblk_assign_free_minor(dev_info);
393         if (rc) {
394                 up_write(&dcssblk_devices_sem);
395                 PRINT_ERR("No free minor number available! "
396                           "Unloading segment...\n");
397                 goto unload_seg;
398         }
399         sprintf(dev_info->gd->disk_name, "dcssblk%d",
400                 dev_info->gd->first_minor);
401         list_add_tail(&dev_info->lh, &dcssblk_devices);
402
403         if (!try_module_get(THIS_MODULE)) {
404                 rc = -ENODEV;
405                 goto list_del;
406         }
407         /*
408          * register the device
409          */
410         rc = device_register(&dev_info->dev);
411         if (rc) {
412                 PRINT_ERR("Segment %s could not be registered RC=%d\n",
413                                 local_buf, rc);
414                 module_put(THIS_MODULE);
415                 goto list_del;
416         }
417         get_device(&dev_info->dev);
418         rc = device_create_file(&dev_info->dev, &dev_attr_shared);
419         if (rc)
420                 goto unregister_dev;
421         rc = device_create_file(&dev_info->dev, &dev_attr_save);
422         if (rc)
423                 goto unregister_dev;
424
425         add_disk(dev_info->gd);
426
427         switch (dev_info->segment_type) {
428                 case SEG_TYPE_SR:
429                 case SEG_TYPE_ER:
430                 case SEG_TYPE_SC:
431                         set_disk_ro(dev_info->gd,1);
432                         break;
433                 default:
434                         set_disk_ro(dev_info->gd,0);
435                         break;
436         }
437         PRINT_DEBUG("Segment %s loaded successfully\n", local_buf);
438         up_write(&dcssblk_devices_sem);
439         rc = count;
440         goto out;
441
442 unregister_dev:
443         list_del(&dev_info->lh);
444         blk_cleanup_queue(dev_info->dcssblk_queue);
445         dev_info->gd->queue = NULL;
446         put_disk(dev_info->gd);
447         device_unregister(&dev_info->dev);
448         segment_unload(dev_info->segment_name);
449         put_device(&dev_info->dev);
450         up_write(&dcssblk_devices_sem);
451         goto out;
452 list_del:
453         list_del(&dev_info->lh);
454         up_write(&dcssblk_devices_sem);
455 unload_seg:
456         segment_unload(local_buf);
457 dealloc_gendisk:
458         blk_cleanup_queue(dev_info->dcssblk_queue);
459         dev_info->gd->queue = NULL;
460         put_disk(dev_info->gd);
461 free_dev_info:
462         kfree(dev_info);
463 out:
464         kfree(local_buf);
465 out_nobuf:
466         return rc;
467 }
468
469 /*
470  * device attribute for removing devices
471  */
472 static ssize_t
473 dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
474 {
475         struct dcssblk_dev_info *dev_info;
476         int rc, i;
477         char *local_buf;
478
479         if (dev != dcssblk_root_dev) {
480                 return -EINVAL;
481         }
482         local_buf = kmalloc(count + 1, GFP_KERNEL);
483         if (local_buf == NULL) {
484                 return -ENOMEM;
485         }
486         /*
487          * parse input
488          */
489         for (i = 0; ((*(buf+i)!='\0') && (*(buf+i)!='\n') && i < count); i++) {
490                 local_buf[i] = toupper(buf[i]);
491         }
492         local_buf[i] = '\0';
493         if ((i == 0) || (i > 8)) {
494                 rc = -ENAMETOOLONG;
495                 goto out_buf;
496         }
497
498         down_write(&dcssblk_devices_sem);
499         dev_info = dcssblk_get_device_by_name(local_buf);
500         if (dev_info == NULL) {
501                 up_write(&dcssblk_devices_sem);
502                 PRINT_WARN("Segment %s is not loaded!\n", local_buf);
503                 rc = -ENODEV;
504                 goto out_buf;
505         }
506         if (atomic_read(&dev_info->use_count) != 0) {
507                 up_write(&dcssblk_devices_sem);
508                 PRINT_WARN("Segment %s is in use!\n", local_buf);
509                 rc = -EBUSY;
510                 goto out_buf;
511         }
512         list_del(&dev_info->lh);
513
514         del_gendisk(dev_info->gd);
515         blk_cleanup_queue(dev_info->dcssblk_queue);
516         dev_info->gd->queue = NULL;
517         put_disk(dev_info->gd);
518         device_unregister(&dev_info->dev);
519         segment_unload(dev_info->segment_name);
520         PRINT_DEBUG("Segment %s unloaded successfully\n",
521                         dev_info->segment_name);
522         put_device(&dev_info->dev);
523         up_write(&dcssblk_devices_sem);
524
525         rc = count;
526 out_buf:
527         kfree(local_buf);
528         return rc;
529 }
530
531 static int
532 dcssblk_open(struct inode *inode, struct file *filp)
533 {
534         struct dcssblk_dev_info *dev_info;
535         int rc;
536
537         dev_info = inode->i_bdev->bd_disk->private_data;
538         if (NULL == dev_info) {
539                 rc = -ENODEV;
540                 goto out;
541         }
542         atomic_inc(&dev_info->use_count);
543         inode->i_bdev->bd_block_size = 4096;
544         rc = 0;
545 out:
546         return rc;
547 }
548
549 static int
550 dcssblk_release(struct inode *inode, struct file *filp)
551 {
552         struct dcssblk_dev_info *dev_info;
553         int rc;
554
555         dev_info = inode->i_bdev->bd_disk->private_data;
556         if (NULL == dev_info) {
557                 rc = -ENODEV;
558                 goto out;
559         }
560         down_write(&dcssblk_devices_sem);
561         if (atomic_dec_and_test(&dev_info->use_count)
562             && (dev_info->save_pending)) {
563                 PRINT_INFO("Segment %s became idle and is being saved now\n",
564                             dev_info->segment_name);
565                 segment_save(dev_info->segment_name);
566                 dev_info->save_pending = 0;
567         }
568         up_write(&dcssblk_devices_sem);
569         rc = 0;
570 out:
571         return rc;
572 }
573
574 static int
575 dcssblk_make_request(struct request_queue *q, struct bio *bio)
576 {
577         struct dcssblk_dev_info *dev_info;
578         struct bio_vec *bvec;
579         unsigned long index;
580         unsigned long page_addr;
581         unsigned long source_addr;
582         unsigned long bytes_done;
583         int i;
584
585         bytes_done = 0;
586         dev_info = bio->bi_bdev->bd_disk->private_data;
587         if (dev_info == NULL)
588                 goto fail;
589         if ((bio->bi_sector & 7) != 0 || (bio->bi_size & 4095) != 0)
590                 /* Request is not page-aligned. */
591                 goto fail;
592         if (((bio->bi_size >> 9) + bio->bi_sector)
593                         > get_capacity(bio->bi_bdev->bd_disk)) {
594                 /* Request beyond end of DCSS segment. */
595                 goto fail;
596         }
597         /* verify data transfer direction */
598         if (dev_info->is_shared) {
599                 switch (dev_info->segment_type) {
600                 case SEG_TYPE_SR:
601                 case SEG_TYPE_ER:
602                 case SEG_TYPE_SC:
603                         /* cannot write to these segments */
604                         if (bio_data_dir(bio) == WRITE) {
605                                 PRINT_WARN("rejecting write to ro segment %s\n", dev_info->dev.bus_id);
606                                 goto fail;
607                         }
608                 }
609         }
610
611         index = (bio->bi_sector >> 3);
612         bio_for_each_segment(bvec, bio, i) {
613                 page_addr = (unsigned long)
614                         page_address(bvec->bv_page) + bvec->bv_offset;
615                 source_addr = dev_info->start + (index<<12) + bytes_done;
616                 if (unlikely((page_addr & 4095) != 0) || (bvec->bv_len & 4095) != 0)
617                         // More paranoia.
618                         goto fail;
619                 if (bio_data_dir(bio) == READ) {
620                         memcpy((void*)page_addr, (void*)source_addr,
621                                 bvec->bv_len);
622                 } else {
623                         memcpy((void*)source_addr, (void*)page_addr,
624                                 bvec->bv_len);
625                 }
626                 bytes_done += bvec->bv_len;
627         }
628         bio_endio(bio, 0);
629         return 0;
630 fail:
631         bio_io_error(bio);
632         return 0;
633 }
634
635 static int
636 dcssblk_direct_access (struct block_device *bdev, sector_t secnum,
637                         void **kaddr, unsigned long *pfn)
638 {
639         struct dcssblk_dev_info *dev_info;
640         unsigned long pgoff;
641
642         dev_info = bdev->bd_disk->private_data;
643         if (!dev_info)
644                 return -ENODEV;
645         if (secnum % (PAGE_SIZE/512))
646                 return -EINVAL;
647         pgoff = secnum / (PAGE_SIZE / 512);
648         if ((pgoff+1)*PAGE_SIZE-1 > dev_info->end - dev_info->start)
649                 return -ERANGE;
650         *kaddr = (void *) (dev_info->start+pgoff*PAGE_SIZE);
651         *pfn = virt_to_phys(*kaddr) >> PAGE_SHIFT;
652
653         return 0;
654 }
655
656 static void
657 dcssblk_check_params(void)
658 {
659         int rc, i, j, k;
660         char buf[9];
661         struct dcssblk_dev_info *dev_info;
662
663         for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0');
664              i++) {
665                 for (j = i; (dcssblk_segments[j] != ',')  &&
666                             (dcssblk_segments[j] != '\0') &&
667                             (dcssblk_segments[j] != '(')  &&
668                             (j - i) < 8; j++)
669                 {
670                         buf[j-i] = dcssblk_segments[j];
671                 }
672                 buf[j-i] = '\0';
673                 rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i);
674                 if ((rc >= 0) && (dcssblk_segments[j] == '(')) {
675                         for (k = 0; buf[k] != '\0'; k++)
676                                 buf[k] = toupper(buf[k]);
677                         if (!strncmp(&dcssblk_segments[j], "(local)", 7)) {
678                                 down_read(&dcssblk_devices_sem);
679                                 dev_info = dcssblk_get_device_by_name(buf);
680                                 up_read(&dcssblk_devices_sem);
681                                 if (dev_info)
682                                         dcssblk_shared_store(&dev_info->dev,
683                                                              NULL, "0\n", 2);
684                         }
685                 }
686                 while ((dcssblk_segments[j] != ',') &&
687                        (dcssblk_segments[j] != '\0'))
688                 {
689                         j++;
690                 }
691                 if (dcssblk_segments[j] == '\0')
692                         break;
693                 i = j;
694         }
695 }
696
697 /*
698  * The init/exit functions.
699  */
700 static void __exit
701 dcssblk_exit(void)
702 {
703         s390_root_dev_unregister(dcssblk_root_dev);
704         unregister_blkdev(dcssblk_major, DCSSBLK_NAME);
705 }
706
707 static int __init
708 dcssblk_init(void)
709 {
710         int rc;
711
712         dcssblk_root_dev = s390_root_dev_register("dcssblk");
713         if (IS_ERR(dcssblk_root_dev))
714                 return PTR_ERR(dcssblk_root_dev);
715         rc = device_create_file(dcssblk_root_dev, &dev_attr_add);
716         if (rc) {
717                 s390_root_dev_unregister(dcssblk_root_dev);
718                 return rc;
719         }
720         rc = device_create_file(dcssblk_root_dev, &dev_attr_remove);
721         if (rc) {
722                 s390_root_dev_unregister(dcssblk_root_dev);
723                 return rc;
724         }
725         rc = register_blkdev(0, DCSSBLK_NAME);
726         if (rc < 0) {
727                 s390_root_dev_unregister(dcssblk_root_dev);
728                 return rc;
729         }
730         dcssblk_major = rc;
731         init_rwsem(&dcssblk_devices_sem);
732
733         dcssblk_check_params();
734
735         return 0;
736 }
737
738 module_init(dcssblk_init);
739 module_exit(dcssblk_exit);
740
741 module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444);
742 MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, "
743                  "comma-separated list, each name max. 8 chars.\n"
744                  "Adding \"(local)\" to segment name equals echoing 0 to "
745                  "/sys/devices/dcssblk/<segment name>/shared after loading "
746                  "the segment - \n"
747                  "e.g. segments=\"mydcss1,mydcss2,mydcss3(local)\"");
748
749 MODULE_LICENSE("GPL");