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