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