]> git.ipfire.org Git - people/ms/linux.git/blob - drivers/s390/char/vmlogrdr.c
Replace <asm/uaccess.h> with <linux/uaccess.h> globally
[people/ms/linux.git] / drivers / s390 / char / vmlogrdr.c
1 /*
2 * character device driver for reading z/VM system service records
3 *
4 *
5 * Copyright IBM Corp. 2004, 2009
6 * character device driver for reading z/VM system service records,
7 * Version 1.0
8 * Author(s): Xenia Tkatschow <xenia@us.ibm.com>
9 * Stefan Weinhuber <wein@de.ibm.com>
10 *
11 */
12
13 #define KMSG_COMPONENT "vmlogrdr"
14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/errno.h>
20 #include <linux/types.h>
21 #include <linux/interrupt.h>
22 #include <linux/spinlock.h>
23 #include <linux/atomic.h>
24 #include <linux/uaccess.h>
25 #include <asm/cpcmd.h>
26 #include <asm/debug.h>
27 #include <asm/ebcdic.h>
28 #include <net/iucv/iucv.h>
29 #include <linux/kmod.h>
30 #include <linux/cdev.h>
31 #include <linux/device.h>
32 #include <linux/string.h>
33
34 MODULE_AUTHOR
35 ("(C) 2004 IBM Corporation by Xenia Tkatschow (xenia@us.ibm.com)\n"
36 " Stefan Weinhuber (wein@de.ibm.com)");
37 MODULE_DESCRIPTION ("Character device driver for reading z/VM "
38 "system service records.");
39 MODULE_LICENSE("GPL");
40
41
42 /*
43 * The size of the buffer for iucv data transfer is one page,
44 * but in addition to the data we read from iucv we also
45 * place an integer and some characters into that buffer,
46 * so the maximum size for record data is a little less then
47 * one page.
48 */
49 #define NET_BUFFER_SIZE (PAGE_SIZE - sizeof(int) - sizeof(FENCE))
50
51 /*
52 * The elements that are concurrently accessed by bottom halves are
53 * connection_established, iucv_path_severed, local_interrupt_buffer
54 * and receive_ready. The first three can be protected by
55 * priv_lock. receive_ready is atomic, so it can be incremented and
56 * decremented without holding a lock.
57 * The variable dev_in_use needs to be protected by the lock, since
58 * it's a flag used by open to make sure that the device is opened only
59 * by one user at the same time.
60 */
61 struct vmlogrdr_priv_t {
62 char system_service[8];
63 char internal_name[8];
64 char recording_name[8];
65 struct iucv_path *path;
66 int connection_established;
67 int iucv_path_severed;
68 struct iucv_message local_interrupt_buffer;
69 atomic_t receive_ready;
70 int minor_num;
71 char * buffer;
72 char * current_position;
73 int remaining;
74 ulong residual_length;
75 int buffer_free;
76 int dev_in_use; /* 1: already opened, 0: not opened*/
77 spinlock_t priv_lock;
78 struct device *device;
79 struct device *class_device;
80 int autorecording;
81 int autopurge;
82 };
83
84
85 /*
86 * File operation structure for vmlogrdr devices
87 */
88 static int vmlogrdr_open(struct inode *, struct file *);
89 static int vmlogrdr_release(struct inode *, struct file *);
90 static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
91 size_t count, loff_t * ppos);
92
93 static const struct file_operations vmlogrdr_fops = {
94 .owner = THIS_MODULE,
95 .open = vmlogrdr_open,
96 .release = vmlogrdr_release,
97 .read = vmlogrdr_read,
98 .llseek = no_llseek,
99 };
100
101
102 static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 *ipuser);
103 static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 *ipuser);
104 static void vmlogrdr_iucv_message_pending(struct iucv_path *,
105 struct iucv_message *);
106
107
108 static struct iucv_handler vmlogrdr_iucv_handler = {
109 .path_complete = vmlogrdr_iucv_path_complete,
110 .path_severed = vmlogrdr_iucv_path_severed,
111 .message_pending = vmlogrdr_iucv_message_pending,
112 };
113
114
115 static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
116 static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
117
118 /*
119 * pointer to system service private structure
120 * minor number 0 --> logrec
121 * minor number 1 --> account
122 * minor number 2 --> symptom
123 */
124
125 static struct vmlogrdr_priv_t sys_ser[] = {
126 { .system_service = "*LOGREC ",
127 .internal_name = "logrec",
128 .recording_name = "EREP",
129 .minor_num = 0,
130 .buffer_free = 1,
131 .priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
132 .autorecording = 1,
133 .autopurge = 1,
134 },
135 { .system_service = "*ACCOUNT",
136 .internal_name = "account",
137 .recording_name = "ACCOUNT",
138 .minor_num = 1,
139 .buffer_free = 1,
140 .priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[1].priv_lock),
141 .autorecording = 1,
142 .autopurge = 1,
143 },
144 { .system_service = "*SYMPTOM",
145 .internal_name = "symptom",
146 .recording_name = "SYMPTOM",
147 .minor_num = 2,
148 .buffer_free = 1,
149 .priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[2].priv_lock),
150 .autorecording = 1,
151 .autopurge = 1,
152 }
153 };
154
155 #define MAXMINOR (sizeof(sys_ser)/sizeof(struct vmlogrdr_priv_t))
156
157 static char FENCE[] = {"EOR"};
158 static int vmlogrdr_major = 0;
159 static struct cdev *vmlogrdr_cdev = NULL;
160 static int recording_class_AB;
161
162
163 static void vmlogrdr_iucv_path_complete(struct iucv_path *path, u8 *ipuser)
164 {
165 struct vmlogrdr_priv_t * logptr = path->private;
166
167 spin_lock(&logptr->priv_lock);
168 logptr->connection_established = 1;
169 spin_unlock(&logptr->priv_lock);
170 wake_up(&conn_wait_queue);
171 }
172
173
174 static void vmlogrdr_iucv_path_severed(struct iucv_path *path, u8 *ipuser)
175 {
176 struct vmlogrdr_priv_t * logptr = path->private;
177 u8 reason = (u8) ipuser[8];
178
179 pr_err("vmlogrdr: connection severed with reason %i\n", reason);
180
181 iucv_path_sever(path, NULL);
182 kfree(path);
183 logptr->path = NULL;
184
185 spin_lock(&logptr->priv_lock);
186 logptr->connection_established = 0;
187 logptr->iucv_path_severed = 1;
188 spin_unlock(&logptr->priv_lock);
189
190 wake_up(&conn_wait_queue);
191 /* just in case we're sleeping waiting for a record */
192 wake_up_interruptible(&read_wait_queue);
193 }
194
195
196 static void vmlogrdr_iucv_message_pending(struct iucv_path *path,
197 struct iucv_message *msg)
198 {
199 struct vmlogrdr_priv_t * logptr = path->private;
200
201 /*
202 * This function is the bottom half so it should be quick.
203 * Copy the external interrupt data into our local eib and increment
204 * the usage count
205 */
206 spin_lock(&logptr->priv_lock);
207 memcpy(&logptr->local_interrupt_buffer, msg, sizeof(*msg));
208 atomic_inc(&logptr->receive_ready);
209 spin_unlock(&logptr->priv_lock);
210 wake_up_interruptible(&read_wait_queue);
211 }
212
213
214 static int vmlogrdr_get_recording_class_AB(void)
215 {
216 static const char cp_command[] = "QUERY COMMAND RECORDING ";
217 char cp_response[80];
218 char *tail;
219 int len,i;
220
221 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
222 len = strnlen(cp_response,sizeof(cp_response));
223 // now the parsing
224 tail=strnchr(cp_response,len,'=');
225 if (!tail)
226 return 0;
227 tail++;
228 if (!strncmp("ANY",tail,3))
229 return 1;
230 if (!strncmp("NONE",tail,4))
231 return 0;
232 /*
233 * expect comma separated list of classes here, if one of them
234 * is A or B return 1 otherwise 0
235 */
236 for (i=tail-cp_response; i<len; i++)
237 if ( cp_response[i]=='A' || cp_response[i]=='B' )
238 return 1;
239 return 0;
240 }
241
242
243 static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
244 int action, int purge)
245 {
246
247 char cp_command[80];
248 char cp_response[160];
249 char *onoff, *qid_string;
250 int rc;
251
252 onoff = ((action == 1) ? "ON" : "OFF");
253 qid_string = ((recording_class_AB == 1) ? " QID * " : "");
254
255 /*
256 * The recording commands needs to be called with option QID
257 * for guests that have previlege classes A or B.
258 * Purging has to be done as separate step, because recording
259 * can't be switched on as long as records are on the queue.
260 * Doing both at the same time doesn't work.
261 */
262 if (purge && (action == 1)) {
263 memset(cp_command, 0x00, sizeof(cp_command));
264 memset(cp_response, 0x00, sizeof(cp_response));
265 snprintf(cp_command, sizeof(cp_command),
266 "RECORDING %s PURGE %s",
267 logptr->recording_name,
268 qid_string);
269 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
270 }
271
272 memset(cp_command, 0x00, sizeof(cp_command));
273 memset(cp_response, 0x00, sizeof(cp_response));
274 snprintf(cp_command, sizeof(cp_command), "RECORDING %s %s %s",
275 logptr->recording_name,
276 onoff,
277 qid_string);
278 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
279 /* The recording command will usually answer with 'Command complete'
280 * on success, but when the specific service was never connected
281 * before then there might be an additional informational message
282 * 'HCPCRC8072I Recording entry not found' before the
283 * 'Command complete'. So I use strstr rather then the strncmp.
284 */
285 if (strstr(cp_response,"Command complete"))
286 rc = 0;
287 else
288 rc = -EIO;
289 /*
290 * If we turn recording off, we have to purge any remaining records
291 * afterwards, as a large number of queued records may impact z/VM
292 * performance.
293 */
294 if (purge && (action == 0)) {
295 memset(cp_command, 0x00, sizeof(cp_command));
296 memset(cp_response, 0x00, sizeof(cp_response));
297 snprintf(cp_command, sizeof(cp_command),
298 "RECORDING %s PURGE %s",
299 logptr->recording_name,
300 qid_string);
301 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
302 }
303
304 return rc;
305 }
306
307
308 static int vmlogrdr_open (struct inode *inode, struct file *filp)
309 {
310 int dev_num = 0;
311 struct vmlogrdr_priv_t * logptr = NULL;
312 int connect_rc = 0;
313 int ret;
314
315 dev_num = iminor(inode);
316 if (dev_num >= MAXMINOR)
317 return -ENODEV;
318 logptr = &sys_ser[dev_num];
319
320 /*
321 * only allow for blocking reads to be open
322 */
323 if (filp->f_flags & O_NONBLOCK)
324 return -EOPNOTSUPP;
325
326 /* Besure this device hasn't already been opened */
327 spin_lock_bh(&logptr->priv_lock);
328 if (logptr->dev_in_use) {
329 spin_unlock_bh(&logptr->priv_lock);
330 return -EBUSY;
331 }
332 logptr->dev_in_use = 1;
333 logptr->connection_established = 0;
334 logptr->iucv_path_severed = 0;
335 atomic_set(&logptr->receive_ready, 0);
336 logptr->buffer_free = 1;
337 spin_unlock_bh(&logptr->priv_lock);
338
339 /* set the file options */
340 filp->private_data = logptr;
341
342 /* start recording for this service*/
343 if (logptr->autorecording) {
344 ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
345 if (ret)
346 pr_warn("vmlogrdr: failed to start recording automatically\n");
347 }
348
349 /* create connection to the system service */
350 logptr->path = iucv_path_alloc(10, 0, GFP_KERNEL);
351 if (!logptr->path)
352 goto out_dev;
353 connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
354 logptr->system_service, NULL, NULL,
355 logptr);
356 if (connect_rc) {
357 pr_err("vmlogrdr: iucv connection to %s "
358 "failed with rc %i \n",
359 logptr->system_service, connect_rc);
360 goto out_path;
361 }
362
363 /* We've issued the connect and now we must wait for a
364 * ConnectionComplete or ConnectinSevered Interrupt
365 * before we can continue to process.
366 */
367 wait_event(conn_wait_queue, (logptr->connection_established)
368 || (logptr->iucv_path_severed));
369 if (logptr->iucv_path_severed)
370 goto out_record;
371 nonseekable_open(inode, filp);
372 return 0;
373
374 out_record:
375 if (logptr->autorecording)
376 vmlogrdr_recording(logptr,0,logptr->autopurge);
377 out_path:
378 kfree(logptr->path); /* kfree(NULL) is ok. */
379 logptr->path = NULL;
380 out_dev:
381 logptr->dev_in_use = 0;
382 return -EIO;
383 }
384
385
386 static int vmlogrdr_release (struct inode *inode, struct file *filp)
387 {
388 int ret;
389
390 struct vmlogrdr_priv_t * logptr = filp->private_data;
391
392 iucv_path_sever(logptr->path, NULL);
393 kfree(logptr->path);
394 logptr->path = NULL;
395 if (logptr->autorecording) {
396 ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
397 if (ret)
398 pr_warn("vmlogrdr: failed to stop recording automatically\n");
399 }
400 logptr->dev_in_use = 0;
401
402 return 0;
403 }
404
405
406 static int vmlogrdr_receive_data(struct vmlogrdr_priv_t *priv)
407 {
408 int rc, *temp;
409 /* we need to keep track of two data sizes here:
410 * The number of bytes we need to receive from iucv and
411 * the total number of bytes we actually write into the buffer.
412 */
413 int user_data_count, iucv_data_count;
414 char * buffer;
415
416 if (atomic_read(&priv->receive_ready)) {
417 spin_lock_bh(&priv->priv_lock);
418 if (priv->residual_length){
419 /* receive second half of a record */
420 iucv_data_count = priv->residual_length;
421 user_data_count = 0;
422 buffer = priv->buffer;
423 } else {
424 /* receive a new record:
425 * We need to return the total length of the record
426 * + size of FENCE in the first 4 bytes of the buffer.
427 */
428 iucv_data_count = priv->local_interrupt_buffer.length;
429 user_data_count = sizeof(int);
430 temp = (int*)priv->buffer;
431 *temp= iucv_data_count + sizeof(FENCE);
432 buffer = priv->buffer + sizeof(int);
433 }
434 /*
435 * If the record is bigger than our buffer, we receive only
436 * a part of it. We can get the rest later.
437 */
438 if (iucv_data_count > NET_BUFFER_SIZE)
439 iucv_data_count = NET_BUFFER_SIZE;
440 rc = iucv_message_receive(priv->path,
441 &priv->local_interrupt_buffer,
442 0, buffer, iucv_data_count,
443 &priv->residual_length);
444 spin_unlock_bh(&priv->priv_lock);
445 /* An rc of 5 indicates that the record was bigger than
446 * the buffer, which is OK for us. A 9 indicates that the
447 * record was purged befor we could receive it.
448 */
449 if (rc == 5)
450 rc = 0;
451 if (rc == 9)
452 atomic_set(&priv->receive_ready, 0);
453 } else {
454 rc = 1;
455 }
456 if (!rc) {
457 priv->buffer_free = 0;
458 user_data_count += iucv_data_count;
459 priv->current_position = priv->buffer;
460 if (priv->residual_length == 0){
461 /* the whole record has been captured,
462 * now add the fence */
463 atomic_dec(&priv->receive_ready);
464 buffer = priv->buffer + user_data_count;
465 memcpy(buffer, FENCE, sizeof(FENCE));
466 user_data_count += sizeof(FENCE);
467 }
468 priv->remaining = user_data_count;
469 }
470
471 return rc;
472 }
473
474
475 static ssize_t vmlogrdr_read(struct file *filp, char __user *data,
476 size_t count, loff_t * ppos)
477 {
478 int rc;
479 struct vmlogrdr_priv_t * priv = filp->private_data;
480
481 while (priv->buffer_free) {
482 rc = vmlogrdr_receive_data(priv);
483 if (rc) {
484 rc = wait_event_interruptible(read_wait_queue,
485 atomic_read(&priv->receive_ready));
486 if (rc)
487 return rc;
488 }
489 }
490 /* copy only up to end of record */
491 if (count > priv->remaining)
492 count = priv->remaining;
493
494 if (copy_to_user(data, priv->current_position, count))
495 return -EFAULT;
496
497 *ppos += count;
498 priv->current_position += count;
499 priv->remaining -= count;
500
501 /* if all data has been transferred, set buffer free */
502 if (priv->remaining == 0)
503 priv->buffer_free = 1;
504
505 return count;
506 }
507
508 static ssize_t vmlogrdr_autopurge_store(struct device * dev,
509 struct device_attribute *attr,
510 const char * buf, size_t count)
511 {
512 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
513 ssize_t ret = count;
514
515 switch (buf[0]) {
516 case '0':
517 priv->autopurge=0;
518 break;
519 case '1':
520 priv->autopurge=1;
521 break;
522 default:
523 ret = -EINVAL;
524 }
525 return ret;
526 }
527
528
529 static ssize_t vmlogrdr_autopurge_show(struct device *dev,
530 struct device_attribute *attr,
531 char *buf)
532 {
533 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
534 return sprintf(buf, "%u\n", priv->autopurge);
535 }
536
537
538 static DEVICE_ATTR(autopurge, 0644, vmlogrdr_autopurge_show,
539 vmlogrdr_autopurge_store);
540
541
542 static ssize_t vmlogrdr_purge_store(struct device * dev,
543 struct device_attribute *attr,
544 const char * buf, size_t count)
545 {
546
547 char cp_command[80];
548 char cp_response[80];
549 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
550
551 if (buf[0] != '1')
552 return -EINVAL;
553
554 memset(cp_command, 0x00, sizeof(cp_command));
555 memset(cp_response, 0x00, sizeof(cp_response));
556
557 /*
558 * The recording command needs to be called with option QID
559 * for guests that have previlege classes A or B.
560 * Other guests will not recognize the command and we have to
561 * issue the same command without the QID parameter.
562 */
563
564 if (recording_class_AB)
565 snprintf(cp_command, sizeof(cp_command),
566 "RECORDING %s PURGE QID * ",
567 priv->recording_name);
568 else
569 snprintf(cp_command, sizeof(cp_command),
570 "RECORDING %s PURGE ",
571 priv->recording_name);
572
573 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
574
575 return count;
576 }
577
578
579 static DEVICE_ATTR(purge, 0200, NULL, vmlogrdr_purge_store);
580
581
582 static ssize_t vmlogrdr_autorecording_store(struct device *dev,
583 struct device_attribute *attr,
584 const char *buf, size_t count)
585 {
586 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
587 ssize_t ret = count;
588
589 switch (buf[0]) {
590 case '0':
591 priv->autorecording=0;
592 break;
593 case '1':
594 priv->autorecording=1;
595 break;
596 default:
597 ret = -EINVAL;
598 }
599 return ret;
600 }
601
602
603 static ssize_t vmlogrdr_autorecording_show(struct device *dev,
604 struct device_attribute *attr,
605 char *buf)
606 {
607 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
608 return sprintf(buf, "%u\n", priv->autorecording);
609 }
610
611
612 static DEVICE_ATTR(autorecording, 0644, vmlogrdr_autorecording_show,
613 vmlogrdr_autorecording_store);
614
615
616 static ssize_t vmlogrdr_recording_store(struct device * dev,
617 struct device_attribute *attr,
618 const char * buf, size_t count)
619 {
620 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
621 ssize_t ret;
622
623 switch (buf[0]) {
624 case '0':
625 ret = vmlogrdr_recording(priv,0,0);
626 break;
627 case '1':
628 ret = vmlogrdr_recording(priv,1,0);
629 break;
630 default:
631 ret = -EINVAL;
632 }
633 if (ret)
634 return ret;
635 else
636 return count;
637
638 }
639
640
641 static DEVICE_ATTR(recording, 0200, NULL, vmlogrdr_recording_store);
642
643
644 static ssize_t vmlogrdr_recording_status_show(struct device_driver *driver,
645 char *buf)
646 {
647
648 static const char cp_command[] = "QUERY RECORDING ";
649 int len;
650
651 cpcmd(cp_command, buf, 4096, NULL);
652 len = strlen(buf);
653 return len;
654 }
655 static DRIVER_ATTR(recording_status, 0444, vmlogrdr_recording_status_show,
656 NULL);
657 static struct attribute *vmlogrdr_drv_attrs[] = {
658 &driver_attr_recording_status.attr,
659 NULL,
660 };
661 static struct attribute_group vmlogrdr_drv_attr_group = {
662 .attrs = vmlogrdr_drv_attrs,
663 };
664 static const struct attribute_group *vmlogrdr_drv_attr_groups[] = {
665 &vmlogrdr_drv_attr_group,
666 NULL,
667 };
668
669 static struct attribute *vmlogrdr_attrs[] = {
670 &dev_attr_autopurge.attr,
671 &dev_attr_purge.attr,
672 &dev_attr_autorecording.attr,
673 &dev_attr_recording.attr,
674 NULL,
675 };
676 static struct attribute_group vmlogrdr_attr_group = {
677 .attrs = vmlogrdr_attrs,
678 };
679 static const struct attribute_group *vmlogrdr_attr_groups[] = {
680 &vmlogrdr_attr_group,
681 NULL,
682 };
683
684 static int vmlogrdr_pm_prepare(struct device *dev)
685 {
686 int rc;
687 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
688
689 rc = 0;
690 if (priv) {
691 spin_lock_bh(&priv->priv_lock);
692 if (priv->dev_in_use)
693 rc = -EBUSY;
694 spin_unlock_bh(&priv->priv_lock);
695 }
696 if (rc)
697 pr_err("vmlogrdr: device %s is busy. Refuse to suspend.\n",
698 dev_name(dev));
699 return rc;
700 }
701
702
703 static const struct dev_pm_ops vmlogrdr_pm_ops = {
704 .prepare = vmlogrdr_pm_prepare,
705 };
706
707 static struct class *vmlogrdr_class;
708 static struct device_driver vmlogrdr_driver = {
709 .name = "vmlogrdr",
710 .bus = &iucv_bus,
711 .pm = &vmlogrdr_pm_ops,
712 .groups = vmlogrdr_drv_attr_groups,
713 };
714
715 static int vmlogrdr_register_driver(void)
716 {
717 int ret;
718
719 /* Register with iucv driver */
720 ret = iucv_register(&vmlogrdr_iucv_handler, 1);
721 if (ret)
722 goto out;
723
724 ret = driver_register(&vmlogrdr_driver);
725 if (ret)
726 goto out_iucv;
727
728 vmlogrdr_class = class_create(THIS_MODULE, "vmlogrdr");
729 if (IS_ERR(vmlogrdr_class)) {
730 ret = PTR_ERR(vmlogrdr_class);
731 vmlogrdr_class = NULL;
732 goto out_driver;
733 }
734 return 0;
735
736 out_driver:
737 driver_unregister(&vmlogrdr_driver);
738 out_iucv:
739 iucv_unregister(&vmlogrdr_iucv_handler, 1);
740 out:
741 return ret;
742 }
743
744
745 static void vmlogrdr_unregister_driver(void)
746 {
747 class_destroy(vmlogrdr_class);
748 vmlogrdr_class = NULL;
749 driver_unregister(&vmlogrdr_driver);
750 iucv_unregister(&vmlogrdr_iucv_handler, 1);
751 }
752
753
754 static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
755 {
756 struct device *dev;
757 int ret;
758
759 dev = kzalloc(sizeof(struct device), GFP_KERNEL);
760 if (dev) {
761 dev_set_name(dev, "%s", priv->internal_name);
762 dev->bus = &iucv_bus;
763 dev->parent = iucv_root;
764 dev->driver = &vmlogrdr_driver;
765 dev->groups = vmlogrdr_attr_groups;
766 dev_set_drvdata(dev, priv);
767 /*
768 * The release function could be called after the
769 * module has been unloaded. It's _only_ task is to
770 * free the struct. Therefore, we specify kfree()
771 * directly here. (Probably a little bit obfuscating
772 * but legitime ...).
773 */
774 dev->release = (void (*)(struct device *))kfree;
775 } else
776 return -ENOMEM;
777 ret = device_register(dev);
778 if (ret) {
779 put_device(dev);
780 return ret;
781 }
782
783 priv->class_device = device_create(vmlogrdr_class, dev,
784 MKDEV(vmlogrdr_major,
785 priv->minor_num),
786 priv, "%s", dev_name(dev));
787 if (IS_ERR(priv->class_device)) {
788 ret = PTR_ERR(priv->class_device);
789 priv->class_device=NULL;
790 device_unregister(dev);
791 return ret;
792 }
793 priv->device = dev;
794 return 0;
795 }
796
797
798 static int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
799 {
800 device_destroy(vmlogrdr_class, MKDEV(vmlogrdr_major, priv->minor_num));
801 if (priv->device != NULL) {
802 device_unregister(priv->device);
803 priv->device=NULL;
804 }
805 return 0;
806 }
807
808
809 static int vmlogrdr_register_cdev(dev_t dev)
810 {
811 int rc = 0;
812 vmlogrdr_cdev = cdev_alloc();
813 if (!vmlogrdr_cdev) {
814 return -ENOMEM;
815 }
816 vmlogrdr_cdev->owner = THIS_MODULE;
817 vmlogrdr_cdev->ops = &vmlogrdr_fops;
818 vmlogrdr_cdev->dev = dev;
819 rc = cdev_add(vmlogrdr_cdev, vmlogrdr_cdev->dev, MAXMINOR);
820 if (!rc)
821 return 0;
822
823 // cleanup: cdev is not fully registered, no cdev_del here!
824 kobject_put(&vmlogrdr_cdev->kobj);
825 vmlogrdr_cdev=NULL;
826 return rc;
827 }
828
829
830 static void vmlogrdr_cleanup(void)
831 {
832 int i;
833
834 if (vmlogrdr_cdev) {
835 cdev_del(vmlogrdr_cdev);
836 vmlogrdr_cdev=NULL;
837 }
838 for (i=0; i < MAXMINOR; ++i ) {
839 vmlogrdr_unregister_device(&sys_ser[i]);
840 free_page((unsigned long)sys_ser[i].buffer);
841 }
842 vmlogrdr_unregister_driver();
843 if (vmlogrdr_major) {
844 unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);
845 vmlogrdr_major=0;
846 }
847 }
848
849
850 static int __init vmlogrdr_init(void)
851 {
852 int rc;
853 int i;
854 dev_t dev;
855
856 if (! MACHINE_IS_VM) {
857 pr_err("not running under VM, driver not loaded.\n");
858 return -ENODEV;
859 }
860
861 recording_class_AB = vmlogrdr_get_recording_class_AB();
862
863 rc = alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
864 if (rc)
865 return rc;
866 vmlogrdr_major = MAJOR(dev);
867
868 rc=vmlogrdr_register_driver();
869 if (rc)
870 goto cleanup;
871
872 for (i=0; i < MAXMINOR; ++i ) {
873 sys_ser[i].buffer = (char *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
874 if (!sys_ser[i].buffer) {
875 rc = -ENOMEM;
876 break;
877 }
878 sys_ser[i].current_position = sys_ser[i].buffer;
879 rc=vmlogrdr_register_device(&sys_ser[i]);
880 if (rc)
881 break;
882 }
883 if (rc)
884 goto cleanup;
885
886 rc = vmlogrdr_register_cdev(dev);
887 if (rc)
888 goto cleanup;
889 return 0;
890
891 cleanup:
892 vmlogrdr_cleanup();
893 return rc;
894 }
895
896
897 static void __exit vmlogrdr_exit(void)
898 {
899 vmlogrdr_cleanup();
900 return;
901 }
902
903
904 module_init(vmlogrdr_init);
905 module_exit(vmlogrdr_exit);