1
2
3
4
5
6
7
8
9
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 <asm/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
34MODULE_AUTHOR
35 ("(C) 2004 IBM Corporation by Xenia Tkatschow (xenia@us.ibm.com)\n"
36 " Stefan Weinhuber (wein@de.ibm.com)");
37MODULE_DESCRIPTION ("Character device driver for reading z/VM "
38 "system service records.");
39MODULE_LICENSE("GPL");
40
41
42
43
44
45
46
47
48
49#define NET_BUFFER_SIZE (PAGE_SIZE - sizeof(int) - sizeof(FENCE))
50
51
52
53
54
55
56
57
58
59
60
61struct 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;
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
87
88static int vmlogrdr_open(struct inode *, struct file *);
89static int vmlogrdr_release(struct inode *, struct file *);
90static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
91 size_t count, loff_t * ppos);
92
93static 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
102static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 *ipuser);
103static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 *ipuser);
104static void vmlogrdr_iucv_message_pending(struct iucv_path *,
105 struct iucv_message *);
106
107
108static 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
115static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
116static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
117
118
119
120
121
122
123
124
125static 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
157static char FENCE[] = {"EOR"};
158static int vmlogrdr_major = 0;
159static struct cdev *vmlogrdr_cdev = NULL;
160static int recording_class_AB;
161
162
163static 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
174static 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
192 wake_up_interruptible(&read_wait_queue);
193}
194
195
196static 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
203
204
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
214static 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
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
234
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
243static 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
257
258
259
260
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
280
281
282
283
284
285 if (strstr(cp_response,"Command complete"))
286 rc = 0;
287 else
288 rc = -EIO;
289
290
291
292
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
308static 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
322
323 if (filp->f_flags & O_NONBLOCK)
324 return -EOPNOTSUPP;
325
326
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
340 filp->private_data = logptr;
341
342
343 if (logptr->autorecording) {
344 ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
345 if (ret)
346 pr_warning("vmlogrdr: failed to start "
347 "recording automatically\n");
348 }
349
350
351 logptr->path = iucv_path_alloc(10, 0, GFP_KERNEL);
352 if (!logptr->path)
353 goto out_dev;
354 connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
355 logptr->system_service, NULL, NULL,
356 logptr);
357 if (connect_rc) {
358 pr_err("vmlogrdr: iucv connection to %s "
359 "failed with rc %i \n",
360 logptr->system_service, connect_rc);
361 goto out_path;
362 }
363
364
365
366
367
368 wait_event(conn_wait_queue, (logptr->connection_established)
369 || (logptr->iucv_path_severed));
370 if (logptr->iucv_path_severed)
371 goto out_record;
372 nonseekable_open(inode, filp);
373 return 0;
374
375out_record:
376 if (logptr->autorecording)
377 vmlogrdr_recording(logptr,0,logptr->autopurge);
378out_path:
379 kfree(logptr->path);
380 logptr->path = NULL;
381out_dev:
382 logptr->dev_in_use = 0;
383 return -EIO;
384}
385
386
387static int vmlogrdr_release (struct inode *inode, struct file *filp)
388{
389 int ret;
390
391 struct vmlogrdr_priv_t * logptr = filp->private_data;
392
393 iucv_path_sever(logptr->path, NULL);
394 kfree(logptr->path);
395 logptr->path = NULL;
396 if (logptr->autorecording) {
397 ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
398 if (ret)
399 pr_warning("vmlogrdr: failed to stop "
400 "recording automatically\n");
401 }
402 logptr->dev_in_use = 0;
403
404 return 0;
405}
406
407
408static int vmlogrdr_receive_data(struct vmlogrdr_priv_t *priv)
409{
410 int rc, *temp;
411
412
413
414
415 int user_data_count, iucv_data_count;
416 char * buffer;
417
418 if (atomic_read(&priv->receive_ready)) {
419 spin_lock_bh(&priv->priv_lock);
420 if (priv->residual_length){
421
422 iucv_data_count = priv->residual_length;
423 user_data_count = 0;
424 buffer = priv->buffer;
425 } else {
426
427
428
429
430 iucv_data_count = priv->local_interrupt_buffer.length;
431 user_data_count = sizeof(int);
432 temp = (int*)priv->buffer;
433 *temp= iucv_data_count + sizeof(FENCE);
434 buffer = priv->buffer + sizeof(int);
435 }
436
437
438
439
440 if (iucv_data_count > NET_BUFFER_SIZE)
441 iucv_data_count = NET_BUFFER_SIZE;
442 rc = iucv_message_receive(priv->path,
443 &priv->local_interrupt_buffer,
444 0, buffer, iucv_data_count,
445 &priv->residual_length);
446 spin_unlock_bh(&priv->priv_lock);
447
448
449
450
451 if (rc == 5)
452 rc = 0;
453 if (rc == 9)
454 atomic_set(&priv->receive_ready, 0);
455 } else {
456 rc = 1;
457 }
458 if (!rc) {
459 priv->buffer_free = 0;
460 user_data_count += iucv_data_count;
461 priv->current_position = priv->buffer;
462 if (priv->residual_length == 0){
463
464
465 atomic_dec(&priv->receive_ready);
466 buffer = priv->buffer + user_data_count;
467 memcpy(buffer, FENCE, sizeof(FENCE));
468 user_data_count += sizeof(FENCE);
469 }
470 priv->remaining = user_data_count;
471 }
472
473 return rc;
474}
475
476
477static ssize_t vmlogrdr_read(struct file *filp, char __user *data,
478 size_t count, loff_t * ppos)
479{
480 int rc;
481 struct vmlogrdr_priv_t * priv = filp->private_data;
482
483 while (priv->buffer_free) {
484 rc = vmlogrdr_receive_data(priv);
485 if (rc) {
486 rc = wait_event_interruptible(read_wait_queue,
487 atomic_read(&priv->receive_ready));
488 if (rc)
489 return rc;
490 }
491 }
492
493 if (count > priv->remaining)
494 count = priv->remaining;
495
496 if (copy_to_user(data, priv->current_position, count))
497 return -EFAULT;
498
499 *ppos += count;
500 priv->current_position += count;
501 priv->remaining -= count;
502
503
504 if (priv->remaining == 0)
505 priv->buffer_free = 1;
506
507 return count;
508}
509
510static ssize_t vmlogrdr_autopurge_store(struct device * dev,
511 struct device_attribute *attr,
512 const char * buf, size_t count)
513{
514 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
515 ssize_t ret = count;
516
517 switch (buf[0]) {
518 case '0':
519 priv->autopurge=0;
520 break;
521 case '1':
522 priv->autopurge=1;
523 break;
524 default:
525 ret = -EINVAL;
526 }
527 return ret;
528}
529
530
531static ssize_t vmlogrdr_autopurge_show(struct device *dev,
532 struct device_attribute *attr,
533 char *buf)
534{
535 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
536 return sprintf(buf, "%u\n", priv->autopurge);
537}
538
539
540static DEVICE_ATTR(autopurge, 0644, vmlogrdr_autopurge_show,
541 vmlogrdr_autopurge_store);
542
543
544static ssize_t vmlogrdr_purge_store(struct device * dev,
545 struct device_attribute *attr,
546 const char * buf, size_t count)
547{
548
549 char cp_command[80];
550 char cp_response[80];
551 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
552
553 if (buf[0] != '1')
554 return -EINVAL;
555
556 memset(cp_command, 0x00, sizeof(cp_command));
557 memset(cp_response, 0x00, sizeof(cp_response));
558
559
560
561
562
563
564
565
566 if (recording_class_AB)
567 snprintf(cp_command, sizeof(cp_command),
568 "RECORDING %s PURGE QID * ",
569 priv->recording_name);
570 else
571 snprintf(cp_command, sizeof(cp_command),
572 "RECORDING %s PURGE ",
573 priv->recording_name);
574
575 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
576
577 return count;
578}
579
580
581static DEVICE_ATTR(purge, 0200, NULL, vmlogrdr_purge_store);
582
583
584static ssize_t vmlogrdr_autorecording_store(struct device *dev,
585 struct device_attribute *attr,
586 const char *buf, size_t count)
587{
588 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
589 ssize_t ret = count;
590
591 switch (buf[0]) {
592 case '0':
593 priv->autorecording=0;
594 break;
595 case '1':
596 priv->autorecording=1;
597 break;
598 default:
599 ret = -EINVAL;
600 }
601 return ret;
602}
603
604
605static ssize_t vmlogrdr_autorecording_show(struct device *dev,
606 struct device_attribute *attr,
607 char *buf)
608{
609 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
610 return sprintf(buf, "%u\n", priv->autorecording);
611}
612
613
614static DEVICE_ATTR(autorecording, 0644, vmlogrdr_autorecording_show,
615 vmlogrdr_autorecording_store);
616
617
618static ssize_t vmlogrdr_recording_store(struct device * dev,
619 struct device_attribute *attr,
620 const char * buf, size_t count)
621{
622 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
623 ssize_t ret;
624
625 switch (buf[0]) {
626 case '0':
627 ret = vmlogrdr_recording(priv,0,0);
628 break;
629 case '1':
630 ret = vmlogrdr_recording(priv,1,0);
631 break;
632 default:
633 ret = -EINVAL;
634 }
635 if (ret)
636 return ret;
637 else
638 return count;
639
640}
641
642
643static DEVICE_ATTR(recording, 0200, NULL, vmlogrdr_recording_store);
644
645
646static ssize_t vmlogrdr_recording_status_show(struct device_driver *driver,
647 char *buf)
648{
649
650 static const char cp_command[] = "QUERY RECORDING ";
651 int len;
652
653 cpcmd(cp_command, buf, 4096, NULL);
654 len = strlen(buf);
655 return len;
656}
657static DRIVER_ATTR(recording_status, 0444, vmlogrdr_recording_status_show,
658 NULL);
659static struct attribute *vmlogrdr_drv_attrs[] = {
660 &driver_attr_recording_status.attr,
661 NULL,
662};
663static struct attribute_group vmlogrdr_drv_attr_group = {
664 .attrs = vmlogrdr_drv_attrs,
665};
666static const struct attribute_group *vmlogrdr_drv_attr_groups[] = {
667 &vmlogrdr_drv_attr_group,
668 NULL,
669};
670
671static struct attribute *vmlogrdr_attrs[] = {
672 &dev_attr_autopurge.attr,
673 &dev_attr_purge.attr,
674 &dev_attr_autorecording.attr,
675 &dev_attr_recording.attr,
676 NULL,
677};
678static struct attribute_group vmlogrdr_attr_group = {
679 .attrs = vmlogrdr_attrs,
680};
681static const struct attribute_group *vmlogrdr_attr_groups[] = {
682 &vmlogrdr_attr_group,
683 NULL,
684};
685
686static int vmlogrdr_pm_prepare(struct device *dev)
687{
688 int rc;
689 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
690
691 rc = 0;
692 if (priv) {
693 spin_lock_bh(&priv->priv_lock);
694 if (priv->dev_in_use)
695 rc = -EBUSY;
696 spin_unlock_bh(&priv->priv_lock);
697 }
698 if (rc)
699 pr_err("vmlogrdr: device %s is busy. Refuse to suspend.\n",
700 dev_name(dev));
701 return rc;
702}
703
704
705static const struct dev_pm_ops vmlogrdr_pm_ops = {
706 .prepare = vmlogrdr_pm_prepare,
707};
708
709static struct class *vmlogrdr_class;
710static struct device_driver vmlogrdr_driver = {
711 .name = "vmlogrdr",
712 .bus = &iucv_bus,
713 .pm = &vmlogrdr_pm_ops,
714 .groups = vmlogrdr_drv_attr_groups,
715};
716
717static int vmlogrdr_register_driver(void)
718{
719 int ret;
720
721
722 ret = iucv_register(&vmlogrdr_iucv_handler, 1);
723 if (ret)
724 goto out;
725
726 ret = driver_register(&vmlogrdr_driver);
727 if (ret)
728 goto out_iucv;
729
730 vmlogrdr_class = class_create(THIS_MODULE, "vmlogrdr");
731 if (IS_ERR(vmlogrdr_class)) {
732 ret = PTR_ERR(vmlogrdr_class);
733 vmlogrdr_class = NULL;
734 goto out_driver;
735 }
736 return 0;
737
738out_driver:
739 driver_unregister(&vmlogrdr_driver);
740out_iucv:
741 iucv_unregister(&vmlogrdr_iucv_handler, 1);
742out:
743 return ret;
744}
745
746
747static void vmlogrdr_unregister_driver(void)
748{
749 class_destroy(vmlogrdr_class);
750 vmlogrdr_class = NULL;
751 driver_unregister(&vmlogrdr_driver);
752 iucv_unregister(&vmlogrdr_iucv_handler, 1);
753}
754
755
756static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
757{
758 struct device *dev;
759 int ret;
760
761 dev = kzalloc(sizeof(struct device), GFP_KERNEL);
762 if (dev) {
763 dev_set_name(dev, "%s", priv->internal_name);
764 dev->bus = &iucv_bus;
765 dev->parent = iucv_root;
766 dev->driver = &vmlogrdr_driver;
767 dev->groups = vmlogrdr_attr_groups;
768 dev_set_drvdata(dev, priv);
769
770
771
772
773
774
775
776 dev->release = (void (*)(struct device *))kfree;
777 } else
778 return -ENOMEM;
779 ret = device_register(dev);
780 if (ret) {
781 put_device(dev);
782 return ret;
783 }
784
785 priv->class_device = device_create(vmlogrdr_class, dev,
786 MKDEV(vmlogrdr_major,
787 priv->minor_num),
788 priv, "%s", dev_name(dev));
789 if (IS_ERR(priv->class_device)) {
790 ret = PTR_ERR(priv->class_device);
791 priv->class_device=NULL;
792 device_unregister(dev);
793 return ret;
794 }
795 priv->device = dev;
796 return 0;
797}
798
799
800static int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
801{
802 device_destroy(vmlogrdr_class, MKDEV(vmlogrdr_major, priv->minor_num));
803 if (priv->device != NULL) {
804 device_unregister(priv->device);
805 priv->device=NULL;
806 }
807 return 0;
808}
809
810
811static int vmlogrdr_register_cdev(dev_t dev)
812{
813 int rc = 0;
814 vmlogrdr_cdev = cdev_alloc();
815 if (!vmlogrdr_cdev) {
816 return -ENOMEM;
817 }
818 vmlogrdr_cdev->owner = THIS_MODULE;
819 vmlogrdr_cdev->ops = &vmlogrdr_fops;
820 vmlogrdr_cdev->dev = dev;
821 rc = cdev_add(vmlogrdr_cdev, vmlogrdr_cdev->dev, MAXMINOR);
822 if (!rc)
823 return 0;
824
825
826 kobject_put(&vmlogrdr_cdev->kobj);
827 vmlogrdr_cdev=NULL;
828 return rc;
829}
830
831
832static void vmlogrdr_cleanup(void)
833{
834 int i;
835
836 if (vmlogrdr_cdev) {
837 cdev_del(vmlogrdr_cdev);
838 vmlogrdr_cdev=NULL;
839 }
840 for (i=0; i < MAXMINOR; ++i ) {
841 vmlogrdr_unregister_device(&sys_ser[i]);
842 free_page((unsigned long)sys_ser[i].buffer);
843 }
844 vmlogrdr_unregister_driver();
845 if (vmlogrdr_major) {
846 unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);
847 vmlogrdr_major=0;
848 }
849}
850
851
852static int __init vmlogrdr_init(void)
853{
854 int rc;
855 int i;
856 dev_t dev;
857
858 if (! MACHINE_IS_VM) {
859 pr_err("not running under VM, driver not loaded.\n");
860 return -ENODEV;
861 }
862
863 recording_class_AB = vmlogrdr_get_recording_class_AB();
864
865 rc = alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
866 if (rc)
867 return rc;
868 vmlogrdr_major = MAJOR(dev);
869
870 rc=vmlogrdr_register_driver();
871 if (rc)
872 goto cleanup;
873
874 for (i=0; i < MAXMINOR; ++i ) {
875 sys_ser[i].buffer = (char *) get_zeroed_page(GFP_KERNEL);
876 if (!sys_ser[i].buffer) {
877 rc = -ENOMEM;
878 break;
879 }
880 sys_ser[i].current_position = sys_ser[i].buffer;
881 rc=vmlogrdr_register_device(&sys_ser[i]);
882 if (rc)
883 break;
884 }
885 if (rc)
886 goto cleanup;
887
888 rc = vmlogrdr_register_cdev(dev);
889 if (rc)
890 goto cleanup;
891 return 0;
892
893cleanup:
894 vmlogrdr_cleanup();
895 return rc;
896}
897
898
899static void __exit vmlogrdr_exit(void)
900{
901 vmlogrdr_cleanup();
902 return;
903}
904
905
906module_init(vmlogrdr_init);
907module_exit(vmlogrdr_exit);
908