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