blob: a8848db7b09dd25f5d7dadb6a743dcb28f0262b0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * character device driver for reading z/VM system service records
3 *
4 *
Stefan Weinhuber9f62fa12009-06-16 10:30:38 +02005 * Copyright IBM Corp. 2004, 2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * 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 */
Martin Schwidefsky5466c2e2008-12-25 13:39:52 +010012
13#define KMSG_COMPONENT "vmlogrdr"
14#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090018#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/errno.h>
20#include <linux/types.h>
21#include <linux/interrupt.h>
22#include <linux/spinlock.h>
Arun Sharma600634972011-07-26 16:09:06 -070023#include <linux/atomic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/uaccess.h>
25#include <asm/cpcmd.h>
26#include <asm/debug.h>
27#include <asm/ebcdic.h>
Martin Schwidefskyc9101c52007-02-08 13:40:41 -080028#include <net/iucv/iucv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/kmod.h>
30#include <linux/cdev.h>
31#include <linux/device.h>
32#include <linux/string.h>
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034MODULE_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 * 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 */
61struct vmlogrdr_priv_t {
62 char system_service[8];
63 char internal_name[8];
64 char recording_name[8];
Martin Schwidefskyc9101c52007-02-08 13:40:41 -080065 struct iucv_path *path;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 int connection_established;
67 int iucv_path_severed;
Martin Schwidefskyc9101c52007-02-08 13:40:41 -080068 struct iucv_message local_interrupt_buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 atomic_t receive_ready;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 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;
Cornelia Huck7f021ce2007-10-22 12:52:42 +020079 struct device *class_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 int autorecording;
81 int autopurge;
82};
83
84
85/*
86 * File operation structure for vmlogrdr devices
87 */
88static int vmlogrdr_open(struct inode *, struct file *);
89static int vmlogrdr_release(struct inode *, struct file *);
Heiko Carstensd2c993d2006-07-12 16:41:55 +020090static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
91 size_t count, loff_t * ppos);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Arjan van de Vend54b1fd2007-02-12 00:55:34 -080093static const struct file_operations vmlogrdr_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 .owner = THIS_MODULE,
95 .open = vmlogrdr_open,
96 .release = vmlogrdr_release,
97 .read = vmlogrdr_read,
Arnd Bergmann6038f372010-08-15 18:52:59 +020098 .llseek = no_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -070099};
100
101
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800102static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 ipuser[16]);
103static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 ipuser[16]);
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,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112};
113
114
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100115static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
116static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
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
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,
Milind Arun Choudharycb629a02007-04-27 16:02:01 +0200131 .priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 .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,
Milind Arun Choudharycb629a02007-04-27 16:02:01 +0200140 .priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[1].priv_lock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 .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,
Milind Arun Choudharycb629a02007-04-27 16:02:01 +0200149 .priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[2].priv_lock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 .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
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800163static void vmlogrdr_iucv_path_complete(struct iucv_path *path, u8 ipuser[16])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800165 struct vmlogrdr_priv_t * logptr = path->private;
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 spin_lock(&logptr->priv_lock);
168 logptr->connection_established = 1;
169 spin_unlock(&logptr->priv_lock);
170 wake_up(&conn_wait_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
173
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800174static void vmlogrdr_iucv_path_severed(struct iucv_path *path, u8 ipuser[16])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800176 struct vmlogrdr_priv_t * logptr = path->private;
177 u8 reason = (u8) ipuser[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Martin Schwidefsky5466c2e2008-12-25 13:39:52 +0100179 pr_err("vmlogrdr: connection severed with reason %i\n", reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800181 iucv_path_sever(path, NULL);
182 kfree(path);
183 logptr->path = NULL;
184
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 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
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800196static void vmlogrdr_iucv_message_pending(struct iucv_path *path,
197 struct iucv_message *msg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800199 struct vmlogrdr_priv_t * logptr = path->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
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);
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800207 memcpy(&logptr->local_interrupt_buffer, msg, sizeof(*msg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 atomic_inc(&logptr->receive_ready);
209 spin_unlock(&logptr->priv_lock);
210 wake_up_interruptible(&read_wait_queue);
211}
212
213
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800214static int vmlogrdr_get_recording_class_AB(void)
215{
Joe Perchesbf2106a2010-10-25 16:10:20 +0200216 static const char cp_command[] = "QUERY COMMAND RECORDING ";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 char cp_response[80];
218 char *tail;
219 int len,i;
220
Christian Borntraeger6b979de2005-06-25 14:55:32 -0700221 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 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
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800243static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
244 int action, int purge)
245{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 char cp_command[80];
248 char cp_response[160];
249 char *onoff, *qid_string;
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100250 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100252 onoff = ((action == 1) ? "ON" : "OFF");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 qid_string = ((recording_class_AB == 1) ? " QID * " : "");
254
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100255 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 * 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 */
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100262 if (purge && (action == 1)) {
263 memset(cp_command, 0x00, sizeof(cp_command));
264 memset(cp_response, 0x00, sizeof(cp_response));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 snprintf(cp_command, sizeof(cp_command),
266 "RECORDING %s PURGE %s",
267 logptr->recording_name,
268 qid_string);
Christian Borntraeger6b979de2005-06-25 14:55:32 -0700269 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
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);
Christian Borntraeger6b979de2005-06-25 14:55:32 -0700278 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 /* 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
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100283 * 'Command complete'. So I use strstr rather then the strncmp.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 */
285 if (strstr(cp_response,"Command complete"))
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100286 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 else
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100288 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Stefan Weinhuberca768b62010-11-10 10:05:54 +0100304 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305}
306
307
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800308static int vmlogrdr_open (struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
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);
Heiko Carstens9784bd42013-10-14 14:26:08 +0200316 if (dev_num >= MAXMINOR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 logptr = &sys_ser[dev_num];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 /*
321 * only allow for blocking reads to be open
322 */
323 if (filp->f_flags & O_NONBLOCK)
Heiko Carstens745e9672012-09-06 17:35:00 +0200324 return -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 }
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800332 logptr->dev_in_use = 1;
333 logptr->connection_established = 0;
334 logptr->iucv_path_severed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 atomic_set(&logptr->receive_ready, 0);
336 logptr->buffer_free = 1;
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800337 spin_unlock_bh(&logptr->priv_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 /* set the file options */
340 filp->private_data = logptr;
341 filp->f_op = &vmlogrdr_fops;
342
343 /* start recording for this service*/
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800344 if (logptr->autorecording) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800346 if (ret)
Martin Schwidefsky5466c2e2008-12-25 13:39:52 +0100347 pr_warning("vmlogrdr: failed to start "
348 "recording automatically\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 }
350
351 /* create connection to the system service */
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800352 logptr->path = iucv_path_alloc(10, 0, GFP_KERNEL);
353 if (!logptr->path)
354 goto out_dev;
355 connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
356 logptr->system_service, NULL, NULL,
357 logptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (connect_rc) {
Martin Schwidefsky5466c2e2008-12-25 13:39:52 +0100359 pr_err("vmlogrdr: iucv connection to %s "
360 "failed with rc %i \n",
361 logptr->system_service, connect_rc);
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800362 goto out_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
364
365 /* We've issued the connect and now we must wait for a
366 * ConnectionComplete or ConnectinSevered Interrupt
367 * before we can continue to process.
368 */
369 wait_event(conn_wait_queue, (logptr->connection_established)
370 || (logptr->iucv_path_severed));
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800371 if (logptr->iucv_path_severed)
372 goto out_record;
Martin Schwidefsky3b47f9d2009-12-07 12:52:23 +0100373 nonseekable_open(inode, filp);
374 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800376out_record:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if (logptr->autorecording)
378 vmlogrdr_recording(logptr,0,logptr->autopurge);
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800379out_path:
380 kfree(logptr->path); /* kfree(NULL) is ok. */
381 logptr->path = NULL;
382out_dev:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 logptr->dev_in_use = 0;
384 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385}
386
387
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800388static int vmlogrdr_release (struct inode *inode, struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
390 int ret;
391
392 struct vmlogrdr_priv_t * logptr = filp->private_data;
393
Ursula Braun66b494a2007-04-27 16:01:52 +0200394 iucv_path_sever(logptr->path, NULL);
395 kfree(logptr->path);
396 logptr->path = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (logptr->autorecording) {
398 ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
399 if (ret)
Martin Schwidefsky5466c2e2008-12-25 13:39:52 +0100400 pr_warning("vmlogrdr: failed to stop "
401 "recording automatically\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
403 logptr->dev_in_use = 0;
404
405 return 0;
406}
407
408
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800409static int vmlogrdr_receive_data(struct vmlogrdr_priv_t *priv)
410{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 int rc, *temp;
412 /* we need to keep track of two data sizes here:
413 * The number of bytes we need to receive from iucv and
414 * the total number of bytes we actually write into the buffer.
415 */
416 int user_data_count, iucv_data_count;
417 char * buffer;
418
419 if (atomic_read(&priv->receive_ready)) {
420 spin_lock_bh(&priv->priv_lock);
421 if (priv->residual_length){
422 /* receive second half of a record */
423 iucv_data_count = priv->residual_length;
424 user_data_count = 0;
425 buffer = priv->buffer;
426 } else {
427 /* receive a new record:
428 * We need to return the total length of the record
429 * + size of FENCE in the first 4 bytes of the buffer.
430 */
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800431 iucv_data_count = priv->local_interrupt_buffer.length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 user_data_count = sizeof(int);
433 temp = (int*)priv->buffer;
434 *temp= iucv_data_count + sizeof(FENCE);
435 buffer = priv->buffer + sizeof(int);
436 }
437 /*
Frederik Schwarzer025dfda2008-10-16 19:02:37 +0200438 * If the record is bigger than our buffer, we receive only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 * a part of it. We can get the rest later.
440 */
441 if (iucv_data_count > NET_BUFFER_SIZE)
442 iucv_data_count = NET_BUFFER_SIZE;
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800443 rc = iucv_message_receive(priv->path,
444 &priv->local_interrupt_buffer,
445 0, buffer, iucv_data_count,
446 &priv->residual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 spin_unlock_bh(&priv->priv_lock);
Frederik Schwarzer025dfda2008-10-16 19:02:37 +0200448 /* An rc of 5 indicates that the record was bigger than
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 * the buffer, which is OK for us. A 9 indicates that the
450 * record was purged befor we could receive it.
451 */
452 if (rc == 5)
453 rc = 0;
454 if (rc == 9)
455 atomic_set(&priv->receive_ready, 0);
456 } else {
457 rc = 1;
458 }
459 if (!rc) {
460 priv->buffer_free = 0;
461 user_data_count += iucv_data_count;
462 priv->current_position = priv->buffer;
463 if (priv->residual_length == 0){
464 /* the whole record has been captured,
465 * now add the fence */
466 atomic_dec(&priv->receive_ready);
467 buffer = priv->buffer + user_data_count;
468 memcpy(buffer, FENCE, sizeof(FENCE));
469 user_data_count += sizeof(FENCE);
470 }
471 priv->remaining = user_data_count;
472 }
473
474 return rc;
475}
476
477
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800478static ssize_t vmlogrdr_read(struct file *filp, char __user *data,
479 size_t count, loff_t * ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
481 int rc;
482 struct vmlogrdr_priv_t * priv = filp->private_data;
483
484 while (priv->buffer_free) {
485 rc = vmlogrdr_receive_data(priv);
486 if (rc) {
487 rc = wait_event_interruptible(read_wait_queue,
488 atomic_read(&priv->receive_ready));
489 if (rc)
490 return rc;
491 }
492 }
493 /* copy only up to end of record */
494 if (count > priv->remaining)
495 count = priv->remaining;
496
497 if (copy_to_user(data, priv->current_position, count))
498 return -EFAULT;
499
500 *ppos += count;
501 priv->current_position += count;
502 priv->remaining -= count;
503
504 /* if all data has been transferred, set buffer free */
505 if (priv->remaining == 0)
506 priv->buffer_free = 1;
507
508 return count;
509}
510
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800511static ssize_t vmlogrdr_autopurge_store(struct device * dev,
512 struct device_attribute *attr,
513 const char * buf, size_t count)
514{
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700515 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 ssize_t ret = count;
517
518 switch (buf[0]) {
519 case '0':
520 priv->autopurge=0;
521 break;
522 case '1':
523 priv->autopurge=1;
524 break;
525 default:
526 ret = -EINVAL;
527 }
528 return ret;
529}
530
531
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800532static ssize_t vmlogrdr_autopurge_show(struct device *dev,
533 struct device_attribute *attr,
534 char *buf)
535{
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700536 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 return sprintf(buf, "%u\n", priv->autopurge);
538}
539
540
541static DEVICE_ATTR(autopurge, 0644, vmlogrdr_autopurge_show,
542 vmlogrdr_autopurge_store);
543
544
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800545static ssize_t vmlogrdr_purge_store(struct device * dev,
546 struct device_attribute *attr,
547 const char * buf, size_t count)
548{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 char cp_command[80];
551 char cp_response[80];
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700552 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 if (buf[0] != '1')
555 return -EINVAL;
556
557 memset(cp_command, 0x00, sizeof(cp_command));
558 memset(cp_response, 0x00, sizeof(cp_response));
559
560 /*
561 * The recording command needs to be called with option QID
562 * for guests that have previlege classes A or B.
563 * Other guests will not recognize the command and we have to
564 * issue the same command without the QID parameter.
565 */
566
567 if (recording_class_AB)
568 snprintf(cp_command, sizeof(cp_command),
569 "RECORDING %s PURGE QID * ",
570 priv->recording_name);
571 else
572 snprintf(cp_command, sizeof(cp_command),
573 "RECORDING %s PURGE ",
574 priv->recording_name);
575
Christian Borntraeger6b979de2005-06-25 14:55:32 -0700576 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 return count;
579}
580
581
582static DEVICE_ATTR(purge, 0200, NULL, vmlogrdr_purge_store);
583
584
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800585static ssize_t vmlogrdr_autorecording_store(struct device *dev,
586 struct device_attribute *attr,
587 const char *buf, size_t count)
588{
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700589 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 ssize_t ret = count;
591
592 switch (buf[0]) {
593 case '0':
594 priv->autorecording=0;
595 break;
596 case '1':
597 priv->autorecording=1;
598 break;
599 default:
600 ret = -EINVAL;
601 }
602 return ret;
603}
604
605
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800606static ssize_t vmlogrdr_autorecording_show(struct device *dev,
607 struct device_attribute *attr,
608 char *buf)
609{
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700610 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 return sprintf(buf, "%u\n", priv->autorecording);
612}
613
614
615static DEVICE_ATTR(autorecording, 0644, vmlogrdr_autorecording_show,
616 vmlogrdr_autorecording_store);
617
618
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800619static ssize_t vmlogrdr_recording_store(struct device * dev,
620 struct device_attribute *attr,
621 const char * buf, size_t count)
622{
Greg Kroah-Hartmandff59b62009-05-04 12:40:54 -0700623 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 ssize_t ret;
625
626 switch (buf[0]) {
627 case '0':
628 ret = vmlogrdr_recording(priv,0,0);
629 break;
630 case '1':
631 ret = vmlogrdr_recording(priv,1,0);
632 break;
633 default:
634 ret = -EINVAL;
635 }
636 if (ret)
637 return ret;
638 else
639 return count;
640
641}
642
643
644static DEVICE_ATTR(recording, 0200, NULL, vmlogrdr_recording_store);
645
646
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800647static ssize_t vmlogrdr_recording_status_show(struct device_driver *driver,
648 char *buf)
649{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Joe Perchesbf2106a2010-10-25 16:10:20 +0200651 static const char cp_command[] = "QUERY RECORDING ";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 int len;
653
Christian Borntraeger6b979de2005-06-25 14:55:32 -0700654 cpcmd(cp_command, buf, 4096, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 len = strlen(buf);
656 return len;
657}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658static DRIVER_ATTR(recording_status, 0444, vmlogrdr_recording_status_show,
659 NULL);
Sebastian Ott72f6e3a2012-06-04 19:33:09 +0200660static struct attribute *vmlogrdr_drv_attrs[] = {
661 &driver_attr_recording_status.attr,
662 NULL,
663};
664static struct attribute_group vmlogrdr_drv_attr_group = {
665 .attrs = vmlogrdr_drv_attrs,
666};
667static const struct attribute_group *vmlogrdr_drv_attr_groups[] = {
668 &vmlogrdr_drv_attr_group,
669 NULL,
670};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
672static struct attribute *vmlogrdr_attrs[] = {
673 &dev_attr_autopurge.attr,
674 &dev_attr_purge.attr,
675 &dev_attr_autorecording.attr,
676 &dev_attr_recording.attr,
677 NULL,
678};
Sebastian Ott76e03772012-06-04 19:32:13 +0200679static struct attribute_group vmlogrdr_attr_group = {
680 .attrs = vmlogrdr_attrs,
681};
682static const struct attribute_group *vmlogrdr_attr_groups[] = {
683 &vmlogrdr_attr_group,
684 NULL,
685};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Stefan Weinhuber9f62fa12009-06-16 10:30:38 +0200687static int vmlogrdr_pm_prepare(struct device *dev)
688{
689 int rc;
Martin Schwidefsky4f0076f2009-06-22 12:08:19 +0200690 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
Stefan Weinhuber9f62fa12009-06-16 10:30:38 +0200691
692 rc = 0;
693 if (priv) {
694 spin_lock_bh(&priv->priv_lock);
695 if (priv->dev_in_use)
696 rc = -EBUSY;
697 spin_unlock_bh(&priv->priv_lock);
698 }
699 if (rc)
700 pr_err("vmlogrdr: device %s is busy. Refuse to suspend.\n",
701 dev_name(dev));
702 return rc;
703}
704
705
Alexey Dobriyan47145212009-12-14 18:00:08 -0800706static const struct dev_pm_ops vmlogrdr_pm_ops = {
Stefan Weinhuber9f62fa12009-06-16 10:30:38 +0200707 .prepare = vmlogrdr_pm_prepare,
708};
709
gregkh@suse.de56b22932005-03-23 10:01:41 -0800710static struct class *vmlogrdr_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711static struct device_driver vmlogrdr_driver = {
712 .name = "vmlogrdr",
713 .bus = &iucv_bus,
Stefan Weinhuber9f62fa12009-06-16 10:30:38 +0200714 .pm = &vmlogrdr_pm_ops,
Sebastian Ott72f6e3a2012-06-04 19:33:09 +0200715 .groups = vmlogrdr_drv_attr_groups,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716};
717
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800718static int vmlogrdr_register_driver(void)
719{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 int ret;
721
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800722 /* Register with iucv driver */
723 ret = iucv_register(&vmlogrdr_iucv_handler, 1);
Martin Schwidefsky2f6f2522008-07-14 09:59:37 +0200724 if (ret)
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800725 goto out;
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 ret = driver_register(&vmlogrdr_driver);
Martin Schwidefsky2f6f2522008-07-14 09:59:37 +0200728 if (ret)
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800729 goto out_iucv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
gregkh@suse.de56b22932005-03-23 10:01:41 -0800731 vmlogrdr_class = class_create(THIS_MODULE, "vmlogrdr");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (IS_ERR(vmlogrdr_class)) {
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800733 ret = PTR_ERR(vmlogrdr_class);
734 vmlogrdr_class = NULL;
Sebastian Ott72f6e3a2012-06-04 19:33:09 +0200735 goto out_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
737 return 0;
738
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800739out_driver:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 driver_unregister(&vmlogrdr_driver);
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800741out_iucv:
742 iucv_unregister(&vmlogrdr_iucv_handler, 1);
743out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 return ret;
745}
746
747
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800748static void vmlogrdr_unregister_driver(void)
749{
gregkh@suse.de56b22932005-03-23 10:01:41 -0800750 class_destroy(vmlogrdr_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 vmlogrdr_class = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 driver_unregister(&vmlogrdr_driver);
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800753 iucv_unregister(&vmlogrdr_iucv_handler, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754}
755
756
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800757static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
758{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 struct device *dev;
760 int ret;
761
Eric Sesterhenn88abaab2006-03-24 03:15:31 -0800762 dev = kzalloc(sizeof(struct device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 if (dev) {
Kees Cookef283688f2014-06-10 10:46:20 -0700764 dev_set_name(dev, "%s", priv->internal_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 dev->bus = &iucv_bus;
766 dev->parent = iucv_root;
767 dev->driver = &vmlogrdr_driver;
Sebastian Ott76e03772012-06-04 19:32:13 +0200768 dev->groups = vmlogrdr_attr_groups;
Martin Schwidefsky4f0076f2009-06-22 12:08:19 +0200769 dev_set_drvdata(dev, priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 /*
771 * The release function could be called after the
772 * module has been unloaded. It's _only_ task is to
773 * free the struct. Therefore, we specify kfree()
774 * directly here. (Probably a little bit obfuscating
775 * but legitime ...).
776 */
777 dev->release = (void (*)(struct device *))kfree;
778 } else
779 return -ENOMEM;
780 ret = device_register(dev);
Sebastian Ottc6304932009-09-11 10:28:38 +0200781 if (ret) {
782 put_device(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 return ret;
Sebastian Ottc6304932009-09-11 10:28:38 +0200784 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Greg Kroah-Hartmanea9e42f2008-07-21 20:03:34 -0700786 priv->class_device = device_create(vmlogrdr_class, dev,
787 MKDEV(vmlogrdr_major,
788 priv->minor_num),
789 priv, "%s", dev_name(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 if (IS_ERR(priv->class_device)) {
791 ret = PTR_ERR(priv->class_device);
792 priv->class_device=NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 device_unregister(dev);
794 return ret;
795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 priv->device = dev;
797 return 0;
798}
799
800
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800801static int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
802{
Cornelia Huck7f021ce2007-10-22 12:52:42 +0200803 device_destroy(vmlogrdr_class, MKDEV(vmlogrdr_major, priv->minor_num));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 if (priv->device != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 device_unregister(priv->device);
806 priv->device=NULL;
807 }
808 return 0;
809}
810
811
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800812static int vmlogrdr_register_cdev(dev_t dev)
813{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 int rc = 0;
815 vmlogrdr_cdev = cdev_alloc();
816 if (!vmlogrdr_cdev) {
817 return -ENOMEM;
818 }
819 vmlogrdr_cdev->owner = THIS_MODULE;
820 vmlogrdr_cdev->ops = &vmlogrdr_fops;
821 vmlogrdr_cdev->dev = dev;
822 rc = cdev_add(vmlogrdr_cdev, vmlogrdr_cdev->dev, MAXMINOR);
823 if (!rc)
824 return 0;
825
826 // cleanup: cdev is not fully registered, no cdev_del here!
827 kobject_put(&vmlogrdr_cdev->kobj);
828 vmlogrdr_cdev=NULL;
829 return rc;
830}
831
832
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800833static void vmlogrdr_cleanup(void)
834{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 int i;
Martin Schwidefskyc9101c52007-02-08 13:40:41 -0800836
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 if (vmlogrdr_cdev) {
838 cdev_del(vmlogrdr_cdev);
839 vmlogrdr_cdev=NULL;
840 }
841 for (i=0; i < MAXMINOR; ++i ) {
842 vmlogrdr_unregister_device(&sys_ser[i]);
843 free_page((unsigned long)sys_ser[i].buffer);
844 }
845 vmlogrdr_unregister_driver();
846 if (vmlogrdr_major) {
847 unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);
848 vmlogrdr_major=0;
849 }
850}
851
852
Christian Borntraegerf60d8912007-07-10 11:24:22 +0200853static int __init vmlogrdr_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854{
855 int rc;
856 int i;
857 dev_t dev;
858
859 if (! MACHINE_IS_VM) {
Martin Schwidefsky5466c2e2008-12-25 13:39:52 +0100860 pr_err("not running under VM, driver not loaded.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 return -ENODEV;
862 }
863
864 recording_class_AB = vmlogrdr_get_recording_class_AB();
865
866 rc = alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
867 if (rc)
868 return rc;
869 vmlogrdr_major = MAJOR(dev);
870
871 rc=vmlogrdr_register_driver();
872 if (rc)
873 goto cleanup;
874
875 for (i=0; i < MAXMINOR; ++i ) {
876 sys_ser[i].buffer = (char *) get_zeroed_page(GFP_KERNEL);
877 if (!sys_ser[i].buffer) {
Marcin Slusarz3cb2cea2008-05-15 16:52:32 +0200878 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 break;
880 }
881 sys_ser[i].current_position = sys_ser[i].buffer;
882 rc=vmlogrdr_register_device(&sys_ser[i]);
883 if (rc)
884 break;
885 }
886 if (rc)
887 goto cleanup;
888
889 rc = vmlogrdr_register_cdev(dev);
890 if (rc)
891 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 return 0;
893
894cleanup:
895 vmlogrdr_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 return rc;
897}
898
899
Christian Borntraegerf60d8912007-07-10 11:24:22 +0200900static void __exit vmlogrdr_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
902 vmlogrdr_cleanup();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 return;
904}
905
906
907module_init(vmlogrdr_init);
908module_exit(vmlogrdr_exit);