cfdcf1aed33c282115e50cf2d6dddd0b96ff5b42
[linux-2.6.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 #define KMSG_COMPONENT "dcssblk"
8 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
9
10 #include <linux/module.h>
11 #include <linux/moduleparam.h>
12 #include <linux/ctype.h>
13 #include <linux/errno.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/blkdev.h>
17 #include <asm/extmem.h>
18 #include <asm/io.h>
19 #include <linux/completion.h>
20 #include <linux/interrupt.h>
21
22 #define DCSSBLK_NAME "dcssblk"
23 #define DCSSBLK_MINORS_PER_DISK 1
24 #define DCSSBLK_PARM_LEN 400
25 #define DCSS_BUS_ID_SIZE 20
26
27 static int dcssblk_open(struct block_device *bdev, fmode_t mode);
28 static int dcssblk_release(struct gendisk *disk, fmode_t mode);
29 static int dcssblk_make_request(struct request_queue *q, struct bio *bio);
30 static int dcssblk_direct_access(struct block_device *bdev, sector_t secnum,
31                                  void **kaddr, unsigned long *pfn);
32
33 static char dcssblk_segments[DCSSBLK_PARM_LEN] = "\0";
34
35 static int dcssblk_major;
36 static struct block_device_operations dcssblk_devops = {
37         .owner          = THIS_MODULE,
38         .open           = dcssblk_open,
39         .release        = dcssblk_release,
40         .direct_access  = dcssblk_direct_access,
41 };
42
43 struct dcssblk_dev_info {
44         struct list_head lh;
45         struct device dev;
46         char segment_name[DCSS_BUS_ID_SIZE];
47         atomic_t use_count;
48         struct gendisk *gd;
49         unsigned long start;
50         unsigned long end;
51         int segment_type;
52         unsigned char save_pending;
53         unsigned char is_shared;
54         struct request_queue *dcssblk_queue;
55         int num_of_segments;
56         struct list_head seg_list;
57 };
58
59 struct segment_info {
60         struct list_head lh;
61         char segment_name[DCSS_BUS_ID_SIZE];
62         unsigned long start;
63         unsigned long end;
64         int segment_type;
65 };
66
67 static ssize_t dcssblk_add_store(struct device * dev, struct device_attribute *attr, const char * buf,
68                                   size_t count);
69 static ssize_t dcssblk_remove_store(struct device * dev, struct device_attribute *attr, const char * buf,
70                                   size_t count);
71 static ssize_t dcssblk_save_store(struct device * dev, struct device_attribute *attr, const char * buf,
72                                   size_t count);
73 static ssize_t dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf);
74 static ssize_t dcssblk_shared_store(struct device * dev, struct device_attribute *attr, const char * buf,
75                                   size_t count);
76 static ssize_t dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf);
77 static ssize_t dcssblk_seglist_show(struct device *dev,
78                                 struct device_attribute *attr,
79                                 char *buf);
80
81 static DEVICE_ATTR(add, S_IWUSR, NULL, dcssblk_add_store);
82 static DEVICE_ATTR(remove, S_IWUSR, NULL, dcssblk_remove_store);
83 static DEVICE_ATTR(save, S_IWUSR | S_IRUSR, dcssblk_save_show,
84                    dcssblk_save_store);
85 static DEVICE_ATTR(shared, S_IWUSR | S_IRUSR, dcssblk_shared_show,
86                    dcssblk_shared_store);
87 static DEVICE_ATTR(seglist, S_IRUSR, dcssblk_seglist_show, NULL);
88
89 static struct device *dcssblk_root_dev;
90
91 static LIST_HEAD(dcssblk_devices);
92 static struct rw_semaphore dcssblk_devices_sem;
93
94 /*
95  * release function for segment device.
96  */
97 static void
98 dcssblk_release_segment(struct device *dev)
99 {
100         struct dcssblk_dev_info *dev_info;
101         struct segment_info *entry, *temp;
102
103         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
104         list_for_each_entry_safe(entry, temp, &dev_info->seg_list, lh) {
105                 list_del(&entry->lh);
106                 kfree(entry);
107         }
108         kfree(dev_info);
109         module_put(THIS_MODULE);
110 }
111
112 /*
113  * get a minor number. needs to be called with
114  * down_write(&dcssblk_devices_sem) and the
115  * device needs to be enqueued before the semaphore is
116  * freed.
117  */
118 static int
119 dcssblk_assign_free_minor(struct dcssblk_dev_info *dev_info)
120 {
121         int minor, found;
122         struct dcssblk_dev_info *entry;
123
124         if (dev_info == NULL)
125                 return -EINVAL;
126         for (minor = 0; minor < (1<<MINORBITS); minor++) {
127                 found = 0;
128                 // test if minor available
129                 list_for_each_entry(entry, &dcssblk_devices, lh)
130                         if (minor == MINOR(disk_devt(entry->gd)))
131                                 found++;
132                 if (!found) break; // got unused minor
133         }
134         if (found)
135                 return -EBUSY;
136         dev_info->gd->first_minor = minor;
137         return 0;
138 }
139
140 /*
141  * get the struct dcssblk_dev_info from dcssblk_devices
142  * for the given name.
143  * down_read(&dcssblk_devices_sem) must be held.
144  */
145 static struct dcssblk_dev_info *
146 dcssblk_get_device_by_name(char *name)
147 {
148         struct dcssblk_dev_info *entry;
149
150         list_for_each_entry(entry, &dcssblk_devices, lh) {
151                 if (!strcmp(name, entry->segment_name)) {
152                         return entry;
153                 }
154         }
155         return NULL;
156 }
157
158 /*
159  * get the struct segment_info from seg_list
160  * for the given name.
161  * down_read(&dcssblk_devices_sem) must be held.
162  */
163 static struct segment_info *
164 dcssblk_get_segment_by_name(char *name)
165 {
166         struct dcssblk_dev_info *dev_info;
167         struct segment_info *entry;
168
169         list_for_each_entry(dev_info, &dcssblk_devices, lh) {
170                 list_for_each_entry(entry, &dev_info->seg_list, lh) {
171                         if (!strcmp(name, entry->segment_name))
172                                 return entry;
173                 }
174         }
175         return NULL;
176 }
177
178 /*
179  * get the highest address of the multi-segment block.
180  */
181 static unsigned long
182 dcssblk_find_highest_addr(struct dcssblk_dev_info *dev_info)
183 {
184         unsigned long highest_addr;
185         struct segment_info *entry;
186
187         highest_addr = 0;
188         list_for_each_entry(entry, &dev_info->seg_list, lh) {
189                 if (highest_addr < entry->end)
190                         highest_addr = entry->end;
191         }
192         return highest_addr;
193 }
194
195 /*
196  * get the lowest address of the multi-segment block.
197  */
198 static unsigned long
199 dcssblk_find_lowest_addr(struct dcssblk_dev_info *dev_info)
200 {
201         int set_first;
202         unsigned long lowest_addr;
203         struct segment_info *entry;
204
205         set_first = 0;
206         lowest_addr = 0;
207         list_for_each_entry(entry, &dev_info->seg_list, lh) {
208                 if (set_first == 0) {
209                         lowest_addr = entry->start;
210                         set_first = 1;
211                 } else {
212                         if (lowest_addr > entry->start)
213                                 lowest_addr = entry->start;
214                 }
215         }
216         return lowest_addr;
217 }
218
219 /*
220  * Check continuity of segments.
221  */
222 static int
223 dcssblk_is_continuous(struct dcssblk_dev_info *dev_info)
224 {
225         int i, j, rc;
226         struct segment_info *sort_list, *entry, temp;
227
228         if (dev_info->num_of_segments <= 1)
229                 return 0;
230
231         sort_list = kzalloc(
232                         sizeof(struct segment_info) * dev_info->num_of_segments,
233                         GFP_KERNEL);
234         if (sort_list == NULL)
235                 return -ENOMEM;
236         i = 0;
237         list_for_each_entry(entry, &dev_info->seg_list, lh) {
238                 memcpy(&sort_list[i], entry, sizeof(struct segment_info));
239                 i++;
240         }
241
242         /* sort segments */
243         for (i = 0; i < dev_info->num_of_segments; i++)
244                 for (j = 0; j < dev_info->num_of_segments; j++)
245                         if (sort_list[j].start > sort_list[i].start) {
246                                 memcpy(&temp, &sort_list[i],
247                                         sizeof(struct segment_info));
248                                 memcpy(&sort_list[i], &sort_list[j],
249                                         sizeof(struct segment_info));
250                                 memcpy(&sort_list[j], &temp,
251                                         sizeof(struct segment_info));
252                         }
253
254         /* check continuity */
255         for (i = 0; i < dev_info->num_of_segments - 1; i++) {
256                 if ((sort_list[i].end + 1) != sort_list[i+1].start) {
257                         pr_err("Adjacent DCSSs %s and %s are not "
258                                "contiguous\n", sort_list[i].segment_name,
259                                sort_list[i+1].segment_name);
260                         rc = -EINVAL;
261                         goto out;
262                 }
263                 /* EN and EW are allowed in a block device */
264                 if (sort_list[i].segment_type != sort_list[i+1].segment_type) {
265                         if (!(sort_list[i].segment_type & SEGMENT_EXCLUSIVE) ||
266                                 (sort_list[i].segment_type == SEG_TYPE_ER) ||
267                                 !(sort_list[i+1].segment_type &
268                                 SEGMENT_EXCLUSIVE) ||
269                                 (sort_list[i+1].segment_type == SEG_TYPE_ER)) {
270                                 pr_err("DCSS %s and DCSS %s have "
271                                        "incompatible types\n",
272                                        sort_list[i].segment_name,
273                                        sort_list[i+1].segment_name);
274                                 rc = -EINVAL;
275                                 goto out;
276                         }
277                 }
278         }
279         rc = 0;
280 out:
281         kfree(sort_list);
282         return rc;
283 }
284
285 /*
286  * Load a segment
287  */
288 static int
289 dcssblk_load_segment(char *name, struct segment_info **seg_info)
290 {
291         int rc;
292
293         /* already loaded? */
294         down_read(&dcssblk_devices_sem);
295         *seg_info = dcssblk_get_segment_by_name(name);
296         up_read(&dcssblk_devices_sem);
297         if (*seg_info != NULL)
298                 return -EEXIST;
299
300         /* get a struct segment_info */
301         *seg_info = kzalloc(sizeof(struct segment_info), GFP_KERNEL);
302         if (*seg_info == NULL)
303                 return -ENOMEM;
304
305         strcpy((*seg_info)->segment_name, name);
306
307         /* load the segment */
308         rc = segment_load(name, SEGMENT_SHARED,
309                         &(*seg_info)->start, &(*seg_info)->end);
310         if (rc < 0) {
311                 segment_warning(rc, (*seg_info)->segment_name);
312                 kfree(*seg_info);
313         } else {
314                 INIT_LIST_HEAD(&(*seg_info)->lh);
315                 (*seg_info)->segment_type = rc;
316         }
317         return rc;
318 }
319
320 static void dcssblk_unregister_callback(struct device *dev)
321 {
322         device_unregister(dev);
323         put_device(dev);
324 }
325
326 /*
327  * device attribute for switching shared/nonshared (exclusive)
328  * operation (show + store)
329  */
330 static ssize_t
331 dcssblk_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
332 {
333         struct dcssblk_dev_info *dev_info;
334
335         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
336         return sprintf(buf, dev_info->is_shared ? "1\n" : "0\n");
337 }
338
339 static ssize_t
340 dcssblk_shared_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
341 {
342         struct dcssblk_dev_info *dev_info;
343         struct segment_info *entry, *temp;
344         int rc;
345
346         if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
347                 return -EINVAL;
348         down_write(&dcssblk_devices_sem);
349         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
350         if (atomic_read(&dev_info->use_count)) {
351                 rc = -EBUSY;
352                 goto out;
353         }
354         if (inbuf[0] == '1') {
355                 /* reload segments in shared mode */
356                 list_for_each_entry(entry, &dev_info->seg_list, lh) {
357                         rc = segment_modify_shared(entry->segment_name,
358                                                 SEGMENT_SHARED);
359                         if (rc < 0) {
360                                 BUG_ON(rc == -EINVAL);
361                                 if (rc != -EAGAIN)
362                                         goto removeseg;
363                         }
364                 }
365                 dev_info->is_shared = 1;
366                 switch (dev_info->segment_type) {
367                 case SEG_TYPE_SR:
368                 case SEG_TYPE_ER:
369                 case SEG_TYPE_SC:
370                         set_disk_ro(dev_info->gd, 1);
371                 }
372         } else if (inbuf[0] == '0') {
373                 /* reload segments in exclusive mode */
374                 if (dev_info->segment_type == SEG_TYPE_SC) {
375                         pr_err("DCSS %s is of type SC and cannot be "
376                                "loaded as exclusive-writable\n",
377                                dev_info->segment_name);
378                         rc = -EINVAL;
379                         goto out;
380                 }
381                 list_for_each_entry(entry, &dev_info->seg_list, lh) {
382                         rc = segment_modify_shared(entry->segment_name,
383                                                    SEGMENT_EXCLUSIVE);
384                         if (rc < 0) {
385                                 BUG_ON(rc == -EINVAL);
386                                 if (rc != -EAGAIN)
387                                         goto removeseg;
388                         }
389                 }
390                 dev_info->is_shared = 0;
391                 set_disk_ro(dev_info->gd, 0);
392         } else {
393                 rc = -EINVAL;
394                 goto out;
395         }
396         rc = count;
397         goto out;
398
399 removeseg:
400         pr_err("DCSS device %s is removed after a failed access mode "
401                "change\n", dev_info->segment_name);
402         temp = entry;
403         list_for_each_entry(entry, &dev_info->seg_list, lh) {
404                 if (entry != temp)
405                         segment_unload(entry->segment_name);
406         }
407         list_del(&dev_info->lh);
408
409         del_gendisk(dev_info->gd);
410         blk_cleanup_queue(dev_info->dcssblk_queue);
411         dev_info->gd->queue = NULL;
412         put_disk(dev_info->gd);
413         rc = device_schedule_callback(dev, dcssblk_unregister_callback);
414 out:
415         up_write(&dcssblk_devices_sem);
416         return rc;
417 }
418
419 /*
420  * device attribute for save operation on current copy
421  * of the segment. If the segment is busy, saving will
422  * become pending until it gets released, which can be
423  * undone by storing a non-true value to this entry.
424  * (show + store)
425  */
426 static ssize_t
427 dcssblk_save_show(struct device *dev, struct device_attribute *attr, char *buf)
428 {
429         struct dcssblk_dev_info *dev_info;
430
431         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
432         return sprintf(buf, dev_info->save_pending ? "1\n" : "0\n");
433 }
434
435 static ssize_t
436 dcssblk_save_store(struct device *dev, struct device_attribute *attr, const char *inbuf, size_t count)
437 {
438         struct dcssblk_dev_info *dev_info;
439         struct segment_info *entry;
440
441         if ((count > 1) && (inbuf[1] != '\n') && (inbuf[1] != '\0'))
442                 return -EINVAL;
443         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
444
445         down_write(&dcssblk_devices_sem);
446         if (inbuf[0] == '1') {
447                 if (atomic_read(&dev_info->use_count) == 0) {
448                         // device is idle => we save immediately
449                         pr_info("All DCSSs that map to device %s are "
450                                 "saved\n", dev_info->segment_name);
451                         list_for_each_entry(entry, &dev_info->seg_list, lh) {
452                                 segment_save(entry->segment_name);
453                         }
454                 }  else {
455                         // device is busy => we save it when it becomes
456                         // idle in dcssblk_release
457                         pr_info("Device %s is in use, its DCSSs will be "
458                                 "saved when it becomes idle\n",
459                                 dev_info->segment_name);
460                         dev_info->save_pending = 1;
461                 }
462         } else if (inbuf[0] == '0') {
463                 if (dev_info->save_pending) {
464                         // device is busy & the user wants to undo his save
465                         // request
466                         dev_info->save_pending = 0;
467                         pr_info("A pending save request for device %s "
468                                 "has been canceled\n",
469                                 dev_info->segment_name);
470                 }
471         } else {
472                 up_write(&dcssblk_devices_sem);
473                 return -EINVAL;
474         }
475         up_write(&dcssblk_devices_sem);
476         return count;
477 }
478
479 /*
480  * device attribute for showing all segments in a device
481  */
482 static ssize_t
483 dcssblk_seglist_show(struct device *dev, struct device_attribute *attr,
484                 char *buf)
485 {
486         int i;
487
488         struct dcssblk_dev_info *dev_info;
489         struct segment_info *entry;
490
491         down_read(&dcssblk_devices_sem);
492         dev_info = container_of(dev, struct dcssblk_dev_info, dev);
493         i = 0;
494         buf[0] = '\0';
495         list_for_each_entry(entry, &dev_info->seg_list, lh) {
496                 strcpy(&buf[i], entry->segment_name);
497                 i += strlen(entry->segment_name);
498                 buf[i] = '\n';
499                 i++;
500         }
501         up_read(&dcssblk_devices_sem);
502         return i;
503 }
504
505 /*
506  * device attribute for adding devices
507  */
508 static ssize_t
509 dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
510 {
511         int rc, i, j, num_of_segments;
512         struct dcssblk_dev_info *dev_info;
513         struct segment_info *seg_info, *temp;
514         char *local_buf;
515         unsigned long seg_byte_size;
516
517         dev_info = NULL;
518         seg_info = NULL;
519         if (dev != dcssblk_root_dev) {
520                 rc = -EINVAL;
521                 goto out_nobuf;
522         }
523         if ((count < 1) || (buf[0] == '\0') || (buf[0] == '\n')) {
524                 rc = -ENAMETOOLONG;
525                 goto out_nobuf;
526         }
527
528         local_buf = kmalloc(count + 1, GFP_KERNEL);
529         if (local_buf == NULL) {
530                 rc = -ENOMEM;
531                 goto out_nobuf;
532         }
533
534         /*
535          * parse input
536          */
537         num_of_segments = 0;
538         for (i = 0; ((buf[i] != '\0') && (buf[i] != '\n') && i < count); i++) {
539                 for (j = i; (buf[j] != ':') &&
540                         (buf[j] != '\0') &&
541                         (buf[j] != '\n') &&
542                         j < count; j++) {
543                         local_buf[j-i] = toupper(buf[j]);
544                 }
545                 local_buf[j-i] = '\0';
546                 if (((j - i) == 0) || ((j - i) > 8)) {
547                         rc = -ENAMETOOLONG;
548                         goto seg_list_del;
549                 }
550
551                 rc = dcssblk_load_segment(local_buf, &seg_info);
552                 if (rc < 0)
553                         goto seg_list_del;
554                 /*
555                  * get a struct dcssblk_dev_info
556                  */
557                 if (num_of_segments == 0) {
558                         dev_info = kzalloc(sizeof(struct dcssblk_dev_info),
559                                         GFP_KERNEL);
560                         if (dev_info == NULL) {
561                                 rc = -ENOMEM;
562                                 goto out;
563                         }
564                         strcpy(dev_info->segment_name, local_buf);
565                         dev_info->segment_type = seg_info->segment_type;
566                         INIT_LIST_HEAD(&dev_info->seg_list);
567                 }
568                 list_add_tail(&seg_info->lh, &dev_info->seg_list);
569                 num_of_segments++;
570                 i = j;
571
572                 if ((buf[j] == '\0') || (buf[j] == '\n'))
573                         break;
574         }
575
576         /* no trailing colon at the end of the input */
577         if ((i > 0) && (buf[i-1] == ':')) {
578                 rc = -ENAMETOOLONG;
579                 goto seg_list_del;
580         }
581         strlcpy(local_buf, buf, i + 1);
582         dev_info->num_of_segments = num_of_segments;
583         rc = dcssblk_is_continuous(dev_info);
584         if (rc < 0)
585                 goto seg_list_del;
586
587         dev_info->start = dcssblk_find_lowest_addr(dev_info);
588         dev_info->end = dcssblk_find_highest_addr(dev_info);
589
590         dev_set_name(&dev_info->dev, dev_info->segment_name);
591         dev_info->dev.release = dcssblk_release_segment;
592         INIT_LIST_HEAD(&dev_info->lh);
593         dev_info->gd = alloc_disk(DCSSBLK_MINORS_PER_DISK);
594         if (dev_info->gd == NULL) {
595                 rc = -ENOMEM;
596                 goto seg_list_del;
597         }
598         dev_info->gd->major = dcssblk_major;
599         dev_info->gd->fops = &dcssblk_devops;
600         dev_info->dcssblk_queue = blk_alloc_queue(GFP_KERNEL);
601         dev_info->gd->queue = dev_info->dcssblk_queue;
602         dev_info->gd->private_data = dev_info;
603         dev_info->gd->driverfs_dev = &dev_info->dev;
604         blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
605         blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096);
606
607         seg_byte_size = (dev_info->end - dev_info->start + 1);
608         set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors
609         pr_info("Loaded %s with total size %lu bytes and capacity %lu "
610                 "sectors\n", local_buf, seg_byte_size, seg_byte_size >> 9);
611
612         dev_info->save_pending = 0;
613         dev_info->is_shared = 1;
614         dev_info->dev.parent = dcssblk_root_dev;
615
616         /*
617          *get minor, add to list
618          */
619         down_write(&dcssblk_devices_sem);
620         if (dcssblk_get_segment_by_name(local_buf)) {
621                 rc = -EEXIST;
622                 goto release_gd;
623         }
624         rc = dcssblk_assign_free_minor(dev_info);
625         if (rc)
626                 goto release_gd;
627         sprintf(dev_info->gd->disk_name, "dcssblk%d",
628                 MINOR(disk_devt(dev_info->gd)));
629         list_add_tail(&dev_info->lh, &dcssblk_devices);
630
631         if (!try_module_get(THIS_MODULE)) {
632                 rc = -ENODEV;
633                 goto dev_list_del;
634         }
635         /*
636          * register the device
637          */
638         rc = device_register(&dev_info->dev);
639         if (rc) {
640                 module_put(THIS_MODULE);
641                 goto dev_list_del;
642         }
643         get_device(&dev_info->dev);
644         rc = device_create_file(&dev_info->dev, &dev_attr_shared);
645         if (rc)
646                 goto unregister_dev;
647         rc = device_create_file(&dev_info->dev, &dev_attr_save);
648         if (rc)
649                 goto unregister_dev;
650         rc = device_create_file(&dev_info->dev, &dev_attr_seglist);
651         if (rc)
652                 goto unregister_dev;
653
654         add_disk(dev_info->gd);
655
656         switch (dev_info->segment_type) {
657                 case SEG_TYPE_SR:
658                 case SEG_TYPE_ER:
659                 case SEG_TYPE_SC:
660                         set_disk_ro(dev_info->gd,1);
661                         break;
662                 default:
663                         set_disk_ro(dev_info->gd,0);
664                         break;
665         }
666         up_write(&dcssblk_devices_sem);
667         rc = count;
668         goto out;
669
670 unregister_dev:
671         list_del(&dev_info->lh);
672         blk_cleanup_queue(dev_info->dcssblk_queue);
673         dev_info->gd->queue = NULL;
674         put_disk(dev_info->gd);
675         device_unregister(&dev_info->dev);
676         list_for_each_entry(seg_info, &dev_info->seg_list, lh) {
677                 segment_unload(seg_info->segment_name);
678         }
679         put_device(&dev_info->dev);
680         up_write(&dcssblk_devices_sem);
681         goto out;
682 dev_list_del:
683         list_del(&dev_info->lh);
684 release_gd:
685         blk_cleanup_queue(dev_info->dcssblk_queue);
686         dev_info->gd->queue = NULL;
687         put_disk(dev_info->gd);
688         up_write(&dcssblk_devices_sem);
689 seg_list_del:
690         if (dev_info == NULL)
691                 goto out;
692         list_for_each_entry_safe(seg_info, temp, &dev_info->seg_list, lh) {
693                 list_del(&seg_info->lh);
694                 segment_unload(seg_info->segment_name);
695                 kfree(seg_info);
696         }
697         kfree(dev_info);
698 out:
699         kfree(local_buf);
700 out_nobuf:
701         return rc;
702 }
703
704 /*
705  * device attribute for removing devices
706  */
707 static ssize_t
708 dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
709 {
710         struct dcssblk_dev_info *dev_info;
711         struct segment_info *entry;
712         int rc, i;
713         char *local_buf;
714
715         if (dev != dcssblk_root_dev) {
716                 return -EINVAL;
717         }
718         local_buf = kmalloc(count + 1, GFP_KERNEL);
719         if (local_buf == NULL) {
720                 return -ENOMEM;
721         }
722         /*
723          * parse input
724          */
725         for (i = 0; ((*(buf+i)!='\0') && (*(buf+i)!='\n') && i < count); i++) {
726                 local_buf[i] = toupper(buf[i]);
727         }
728         local_buf[i] = '\0';
729         if ((i == 0) || (i > 8)) {
730                 rc = -ENAMETOOLONG;
731                 goto out_buf;
732         }
733
734         down_write(&dcssblk_devices_sem);
735         dev_info = dcssblk_get_device_by_name(local_buf);
736         if (dev_info == NULL) {
737                 up_write(&dcssblk_devices_sem);
738                 pr_warning("Device %s cannot be removed because it is not a "
739                            "known device\n", local_buf);
740                 rc = -ENODEV;
741                 goto out_buf;
742         }
743         if (atomic_read(&dev_info->use_count) != 0) {
744                 up_write(&dcssblk_devices_sem);
745                 pr_warning("Device %s cannot be removed while it is in "
746                            "use\n", local_buf);
747                 rc = -EBUSY;
748                 goto out_buf;
749         }
750
751         list_del(&dev_info->lh);
752         del_gendisk(dev_info->gd);
753         blk_cleanup_queue(dev_info->dcssblk_queue);
754         dev_info->gd->queue = NULL;
755         put_disk(dev_info->gd);
756         device_unregister(&dev_info->dev);
757
758         /* unload all related segments */
759         list_for_each_entry(entry, &dev_info->seg_list, lh)
760                 segment_unload(entry->segment_name);
761
762         put_device(&dev_info->dev);
763         up_write(&dcssblk_devices_sem);
764
765         rc = count;
766 out_buf:
767         kfree(local_buf);
768         return rc;
769 }
770
771 static int
772 dcssblk_open(struct block_device *bdev, fmode_t mode)
773 {
774         struct dcssblk_dev_info *dev_info;
775         int rc;
776
777         dev_info = bdev->bd_disk->private_data;
778         if (NULL == dev_info) {
779                 rc = -ENODEV;
780                 goto out;
781         }
782         atomic_inc(&dev_info->use_count);
783         bdev->bd_block_size = 4096;
784         rc = 0;
785 out:
786         return rc;
787 }
788
789 static int
790 dcssblk_release(struct gendisk *disk, fmode_t mode)
791 {
792         struct dcssblk_dev_info *dev_info = disk->private_data;
793         struct segment_info *entry;
794         int rc;
795
796         if (!dev_info) {
797                 rc = -ENODEV;
798                 goto out;
799         }
800         down_write(&dcssblk_devices_sem);
801         if (atomic_dec_and_test(&dev_info->use_count)
802             && (dev_info->save_pending)) {
803                 pr_info("Device %s has become idle and is being saved "
804                         "now\n", dev_info->segment_name);
805                 list_for_each_entry(entry, &dev_info->seg_list, lh) {
806                         segment_save(entry->segment_name);
807                 }
808                 dev_info->save_pending = 0;
809         }
810         up_write(&dcssblk_devices_sem);
811         rc = 0;
812 out:
813         return rc;
814 }
815
816 static int
817 dcssblk_make_request(struct request_queue *q, struct bio *bio)
818 {
819         struct dcssblk_dev_info *dev_info;
820         struct bio_vec *bvec;
821         unsigned long index;
822         unsigned long page_addr;
823         unsigned long source_addr;
824         unsigned long bytes_done;
825         int i;
826
827         bytes_done = 0;
828         dev_info = bio->bi_bdev->bd_disk->private_data;
829         if (dev_info == NULL)
830                 goto fail;
831         if ((bio->bi_sector & 7) != 0 || (bio->bi_size & 4095) != 0)
832                 /* Request is not page-aligned. */
833                 goto fail;
834         if (((bio->bi_size >> 9) + bio->bi_sector)
835                         > get_capacity(bio->bi_bdev->bd_disk)) {
836                 /* Request beyond end of DCSS segment. */
837                 goto fail;
838         }
839         /* verify data transfer direction */
840         if (dev_info->is_shared) {
841                 switch (dev_info->segment_type) {
842                 case SEG_TYPE_SR:
843                 case SEG_TYPE_ER:
844                 case SEG_TYPE_SC:
845                         /* cannot write to these segments */
846                         if (bio_data_dir(bio) == WRITE) {
847                                 pr_warning("Writing to %s failed because it "
848                                            "is a read-only device\n",
849                                            dev_name(&dev_info->dev));
850                                 goto fail;
851                         }
852                 }
853         }
854
855         index = (bio->bi_sector >> 3);
856         bio_for_each_segment(bvec, bio, i) {
857                 page_addr = (unsigned long)
858                         page_address(bvec->bv_page) + bvec->bv_offset;
859                 source_addr = dev_info->start + (index<<12) + bytes_done;
860                 if (unlikely((page_addr & 4095) != 0) || (bvec->bv_len & 4095) != 0)
861                         // More paranoia.
862                         goto fail;
863                 if (bio_data_dir(bio) == READ) {
864                         memcpy((void*)page_addr, (void*)source_addr,
865                                 bvec->bv_len);
866                 } else {
867                         memcpy((void*)source_addr, (void*)page_addr,
868                                 bvec->bv_len);
869                 }
870                 bytes_done += bvec->bv_len;
871         }
872         bio_endio(bio, 0);
873         return 0;
874 fail:
875         bio_io_error(bio);
876         return 0;
877 }
878
879 static int
880 dcssblk_direct_access (struct block_device *bdev, sector_t secnum,
881                         void **kaddr, unsigned long *pfn)
882 {
883         struct dcssblk_dev_info *dev_info;
884         unsigned long pgoff;
885
886         dev_info = bdev->bd_disk->private_data;
887         if (!dev_info)
888                 return -ENODEV;
889         if (secnum % (PAGE_SIZE/512))
890                 return -EINVAL;
891         pgoff = secnum / (PAGE_SIZE / 512);
892         if ((pgoff+1)*PAGE_SIZE-1 > dev_info->end - dev_info->start)
893                 return -ERANGE;
894         *kaddr = (void *) (dev_info->start+pgoff*PAGE_SIZE);
895         *pfn = virt_to_phys(*kaddr) >> PAGE_SHIFT;
896
897         return 0;
898 }
899
900 static void
901 dcssblk_check_params(void)
902 {
903         int rc, i, j, k;
904         char buf[DCSSBLK_PARM_LEN + 1];
905         struct dcssblk_dev_info *dev_info;
906
907         for (i = 0; (i < DCSSBLK_PARM_LEN) && (dcssblk_segments[i] != '\0');
908              i++) {
909                 for (j = i; (dcssblk_segments[j] != ',')  &&
910                             (dcssblk_segments[j] != '\0') &&
911                             (dcssblk_segments[j] != '(')  &&
912                             (j < DCSSBLK_PARM_LEN); j++)
913                 {
914                         buf[j-i] = dcssblk_segments[j];
915                 }
916                 buf[j-i] = '\0';
917                 rc = dcssblk_add_store(dcssblk_root_dev, NULL, buf, j-i);
918                 if ((rc >= 0) && (dcssblk_segments[j] == '(')) {
919                         for (k = 0; (buf[k] != ':') && (buf[k] != '\0'); k++)
920                                 buf[k] = toupper(buf[k]);
921                         buf[k] = '\0';
922                         if (!strncmp(&dcssblk_segments[j], "(local)", 7)) {
923                                 down_read(&dcssblk_devices_sem);
924                                 dev_info = dcssblk_get_device_by_name(buf);
925                                 up_read(&dcssblk_devices_sem);
926                                 if (dev_info)
927                                         dcssblk_shared_store(&dev_info->dev,
928                                                              NULL, "0\n", 2);
929                         }
930                 }
931                 while ((dcssblk_segments[j] != ',') &&
932                        (dcssblk_segments[j] != '\0'))
933                 {
934                         j++;
935                 }
936                 if (dcssblk_segments[j] == '\0')
937                         break;
938                 i = j;
939         }
940 }
941
942 /*
943  * The init/exit functions.
944  */
945 static void __exit
946 dcssblk_exit(void)
947 {
948         root_device_unregister(dcssblk_root_dev);
949         unregister_blkdev(dcssblk_major, DCSSBLK_NAME);
950 }
951
952 static int __init
953 dcssblk_init(void)
954 {
955         int rc;
956
957         dcssblk_root_dev = root_device_register("dcssblk");
958         if (IS_ERR(dcssblk_root_dev))
959                 return PTR_ERR(dcssblk_root_dev);
960         rc = device_create_file(dcssblk_root_dev, &dev_attr_add);
961         if (rc) {
962                 root_device_unregister(dcssblk_root_dev);
963                 return rc;
964         }
965         rc = device_create_file(dcssblk_root_dev, &dev_attr_remove);
966         if (rc) {
967                 root_device_unregister(dcssblk_root_dev);
968                 return rc;
969         }
970         rc = register_blkdev(0, DCSSBLK_NAME);
971         if (rc < 0) {
972                 root_device_unregister(dcssblk_root_dev);
973                 return rc;
974         }
975         dcssblk_major = rc;
976         init_rwsem(&dcssblk_devices_sem);
977
978         dcssblk_check_params();
979
980         return 0;
981 }
982
983 module_init(dcssblk_init);
984 module_exit(dcssblk_exit);
985
986 module_param_string(segments, dcssblk_segments, DCSSBLK_PARM_LEN, 0444);
987 MODULE_PARM_DESC(segments, "Name of DCSS segment(s) to be loaded, "
988                  "comma-separated list, names in each set separated "
989                  "by commas are separated by colons, each set contains "
990                  "names of contiguous segments and each name max. 8 chars.\n"
991                  "Adding \"(local)\" to the end of each set equals echoing 0 "
992                  "to /sys/devices/dcssblk/<device name>/shared after loading "
993                  "the contiguous segments - \n"
994                  "e.g. segments=\"mydcss1,mydcss2:mydcss3,mydcss4(local)\"");
995
996 MODULE_LICENSE("GPL");