source: src/linux/universal/linux-4.9/drivers/s390/block/dcssblk.c @ 31662

Last change on this file since 31662 was 31662, checked in by brainslayer, 7 weeks ago

use new squashfs in all kernels

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