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