![Tejun Heo](/assets/img/avatar_default.png)
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
900 lines
21 KiB
C
900 lines
21 KiB
C
/*
|
|
* drivers/s390/char/vmlogrdr.c
|
|
* character device driver for reading z/VM system service records
|
|
*
|
|
*
|
|
* Copyright IBM Corp. 2004, 2009
|
|
* character device driver for reading z/VM system service records,
|
|
* Version 1.0
|
|
* Author(s): Xenia Tkatschow <xenia@us.ibm.com>
|
|
* Stefan Weinhuber <wein@de.ibm.com>
|
|
*
|
|
*/
|
|
|
|
#define KMSG_COMPONENT "vmlogrdr"
|
|
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/types.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/spinlock.h>
|
|
#include <asm/atomic.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/cpcmd.h>
|
|
#include <asm/debug.h>
|
|
#include <asm/ebcdic.h>
|
|
#include <net/iucv/iucv.h>
|
|
#include <linux/kmod.h>
|
|
#include <linux/cdev.h>
|
|
#include <linux/device.h>
|
|
#include <linux/smp_lock.h>
|
|
#include <linux/string.h>
|
|
|
|
MODULE_AUTHOR
|
|
("(C) 2004 IBM Corporation by Xenia Tkatschow (xenia@us.ibm.com)\n"
|
|
" Stefan Weinhuber (wein@de.ibm.com)");
|
|
MODULE_DESCRIPTION ("Character device driver for reading z/VM "
|
|
"system service records.");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
/*
|
|
* The size of the buffer for iucv data transfer is one page,
|
|
* but in addition to the data we read from iucv we also
|
|
* place an integer and some characters into that buffer,
|
|
* so the maximum size for record data is a little less then
|
|
* one page.
|
|
*/
|
|
#define NET_BUFFER_SIZE (PAGE_SIZE - sizeof(int) - sizeof(FENCE))
|
|
|
|
/*
|
|
* The elements that are concurrently accessed by bottom halves are
|
|
* connection_established, iucv_path_severed, local_interrupt_buffer
|
|
* and receive_ready. The first three can be protected by
|
|
* priv_lock. receive_ready is atomic, so it can be incremented and
|
|
* decremented without holding a lock.
|
|
* The variable dev_in_use needs to be protected by the lock, since
|
|
* it's a flag used by open to make sure that the device is opened only
|
|
* by one user at the same time.
|
|
*/
|
|
struct vmlogrdr_priv_t {
|
|
char system_service[8];
|
|
char internal_name[8];
|
|
char recording_name[8];
|
|
struct iucv_path *path;
|
|
int connection_established;
|
|
int iucv_path_severed;
|
|
struct iucv_message local_interrupt_buffer;
|
|
atomic_t receive_ready;
|
|
int minor_num;
|
|
char * buffer;
|
|
char * current_position;
|
|
int remaining;
|
|
ulong residual_length;
|
|
int buffer_free;
|
|
int dev_in_use; /* 1: already opened, 0: not opened*/
|
|
spinlock_t priv_lock;
|
|
struct device *device;
|
|
struct device *class_device;
|
|
int autorecording;
|
|
int autopurge;
|
|
};
|
|
|
|
|
|
/*
|
|
* File operation structure for vmlogrdr devices
|
|
*/
|
|
static int vmlogrdr_open(struct inode *, struct file *);
|
|
static int vmlogrdr_release(struct inode *, struct file *);
|
|
static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
|
|
size_t count, loff_t * ppos);
|
|
|
|
static const struct file_operations vmlogrdr_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = vmlogrdr_open,
|
|
.release = vmlogrdr_release,
|
|
.read = vmlogrdr_read,
|
|
};
|
|
|
|
|
|
static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 ipuser[16]);
|
|
static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 ipuser[16]);
|
|
static void vmlogrdr_iucv_message_pending(struct iucv_path *,
|
|
struct iucv_message *);
|
|
|
|
|
|
static struct iucv_handler vmlogrdr_iucv_handler = {
|
|
.path_complete = vmlogrdr_iucv_path_complete,
|
|
.path_severed = vmlogrdr_iucv_path_severed,
|
|
.message_pending = vmlogrdr_iucv_message_pending,
|
|
};
|
|
|
|
|
|
static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
|
|
static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
|
|
|
|
/*
|
|
* pointer to system service private structure
|
|
* minor number 0 --> logrec
|
|
* minor number 1 --> account
|
|
* minor number 2 --> symptom
|
|
*/
|
|
|
|
static struct vmlogrdr_priv_t sys_ser[] = {
|
|
{ .system_service = "*LOGREC ",
|
|
.internal_name = "logrec",
|
|
.recording_name = "EREP",
|
|
.minor_num = 0,
|
|
.buffer_free = 1,
|
|
.priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
|
|
.autorecording = 1,
|
|
.autopurge = 1,
|
|
},
|
|
{ .system_service = "*ACCOUNT",
|
|
.internal_name = "account",
|
|
.recording_name = "ACCOUNT",
|
|
.minor_num = 1,
|
|
.buffer_free = 1,
|
|
.priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[1].priv_lock),
|
|
.autorecording = 1,
|
|
.autopurge = 1,
|
|
},
|
|
{ .system_service = "*SYMPTOM",
|
|
.internal_name = "symptom",
|
|
.recording_name = "SYMPTOM",
|
|
.minor_num = 2,
|
|
.buffer_free = 1,
|
|
.priv_lock = __SPIN_LOCK_UNLOCKED(sys_ser[2].priv_lock),
|
|
.autorecording = 1,
|
|
.autopurge = 1,
|
|
}
|
|
};
|
|
|
|
#define MAXMINOR (sizeof(sys_ser)/sizeof(struct vmlogrdr_priv_t))
|
|
|
|
static char FENCE[] = {"EOR"};
|
|
static int vmlogrdr_major = 0;
|
|
static struct cdev *vmlogrdr_cdev = NULL;
|
|
static int recording_class_AB;
|
|
|
|
|
|
static void vmlogrdr_iucv_path_complete(struct iucv_path *path, u8 ipuser[16])
|
|
{
|
|
struct vmlogrdr_priv_t * logptr = path->private;
|
|
|
|
spin_lock(&logptr->priv_lock);
|
|
logptr->connection_established = 1;
|
|
spin_unlock(&logptr->priv_lock);
|
|
wake_up(&conn_wait_queue);
|
|
}
|
|
|
|
|
|
static void vmlogrdr_iucv_path_severed(struct iucv_path *path, u8 ipuser[16])
|
|
{
|
|
struct vmlogrdr_priv_t * logptr = path->private;
|
|
u8 reason = (u8) ipuser[8];
|
|
|
|
pr_err("vmlogrdr: connection severed with reason %i\n", reason);
|
|
|
|
iucv_path_sever(path, NULL);
|
|
kfree(path);
|
|
logptr->path = NULL;
|
|
|
|
spin_lock(&logptr->priv_lock);
|
|
logptr->connection_established = 0;
|
|
logptr->iucv_path_severed = 1;
|
|
spin_unlock(&logptr->priv_lock);
|
|
|
|
wake_up(&conn_wait_queue);
|
|
/* just in case we're sleeping waiting for a record */
|
|
wake_up_interruptible(&read_wait_queue);
|
|
}
|
|
|
|
|
|
static void vmlogrdr_iucv_message_pending(struct iucv_path *path,
|
|
struct iucv_message *msg)
|
|
{
|
|
struct vmlogrdr_priv_t * logptr = path->private;
|
|
|
|
/*
|
|
* This function is the bottom half so it should be quick.
|
|
* Copy the external interrupt data into our local eib and increment
|
|
* the usage count
|
|
*/
|
|
spin_lock(&logptr->priv_lock);
|
|
memcpy(&logptr->local_interrupt_buffer, msg, sizeof(*msg));
|
|
atomic_inc(&logptr->receive_ready);
|
|
spin_unlock(&logptr->priv_lock);
|
|
wake_up_interruptible(&read_wait_queue);
|
|
}
|
|
|
|
|
|
static int vmlogrdr_get_recording_class_AB(void)
|
|
{
|
|
char cp_command[]="QUERY COMMAND RECORDING ";
|
|
char cp_response[80];
|
|
char *tail;
|
|
int len,i;
|
|
|
|
cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
|
|
len = strnlen(cp_response,sizeof(cp_response));
|
|
// now the parsing
|
|
tail=strnchr(cp_response,len,'=');
|
|
if (!tail)
|
|
return 0;
|
|
tail++;
|
|
if (!strncmp("ANY",tail,3))
|
|
return 1;
|
|
if (!strncmp("NONE",tail,4))
|
|
return 0;
|
|
/*
|
|
* expect comma separated list of classes here, if one of them
|
|
* is A or B return 1 otherwise 0
|
|
*/
|
|
for (i=tail-cp_response; i<len; i++)
|
|
if ( cp_response[i]=='A' || cp_response[i]=='B' )
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
|
|
int action, int purge)
|
|
{
|
|
|
|
char cp_command[80];
|
|
char cp_response[160];
|
|
char *onoff, *qid_string;
|
|
|
|
memset(cp_command, 0x00, sizeof(cp_command));
|
|
memset(cp_response, 0x00, sizeof(cp_response));
|
|
|
|
onoff = ((action == 1) ? "ON" : "OFF");
|
|
qid_string = ((recording_class_AB == 1) ? " QID * " : "");
|
|
|
|
/*
|
|
* The recording commands needs to be called with option QID
|
|
* for guests that have previlege classes A or B.
|
|
* Purging has to be done as separate step, because recording
|
|
* can't be switched on as long as records are on the queue.
|
|
* Doing both at the same time doesn't work.
|
|
*/
|
|
|
|
if (purge) {
|
|
snprintf(cp_command, sizeof(cp_command),
|
|
"RECORDING %s PURGE %s",
|
|
logptr->recording_name,
|
|
qid_string);
|
|
|
|
cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
|
|
}
|
|
|
|
memset(cp_command, 0x00, sizeof(cp_command));
|
|
memset(cp_response, 0x00, sizeof(cp_response));
|
|
snprintf(cp_command, sizeof(cp_command), "RECORDING %s %s %s",
|
|
logptr->recording_name,
|
|
onoff,
|
|
qid_string);
|
|
|
|
cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
|
|
/* The recording command will usually answer with 'Command complete'
|
|
* on success, but when the specific service was never connected
|
|
* before then there might be an additional informational message
|
|
* 'HCPCRC8072I Recording entry not found' before the
|
|
* 'Command complete'. So I use strstr rather then the strncmp.
|
|
*/
|
|
if (strstr(cp_response,"Command complete"))
|
|
return 0;
|
|
else
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
static int vmlogrdr_open (struct inode *inode, struct file *filp)
|
|
{
|
|
int dev_num = 0;
|
|
struct vmlogrdr_priv_t * logptr = NULL;
|
|
int connect_rc = 0;
|
|
int ret;
|
|
|
|
dev_num = iminor(inode);
|
|
if (dev_num > MAXMINOR)
|
|
return -ENODEV;
|
|
logptr = &sys_ser[dev_num];
|
|
|
|
/*
|
|
* only allow for blocking reads to be open
|
|
*/
|
|
if (filp->f_flags & O_NONBLOCK)
|
|
return -ENOSYS;
|
|
|
|
/* Besure this device hasn't already been opened */
|
|
spin_lock_bh(&logptr->priv_lock);
|
|
if (logptr->dev_in_use) {
|
|
spin_unlock_bh(&logptr->priv_lock);
|
|
return -EBUSY;
|
|
}
|
|
logptr->dev_in_use = 1;
|
|
logptr->connection_established = 0;
|
|
logptr->iucv_path_severed = 0;
|
|
atomic_set(&logptr->receive_ready, 0);
|
|
logptr->buffer_free = 1;
|
|
spin_unlock_bh(&logptr->priv_lock);
|
|
|
|
/* set the file options */
|
|
filp->private_data = logptr;
|
|
filp->f_op = &vmlogrdr_fops;
|
|
|
|
/* start recording for this service*/
|
|
if (logptr->autorecording) {
|
|
ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
|
|
if (ret)
|
|
pr_warning("vmlogrdr: failed to start "
|
|
"recording automatically\n");
|
|
}
|
|
|
|
/* create connection to the system service */
|
|
logptr->path = iucv_path_alloc(10, 0, GFP_KERNEL);
|
|
if (!logptr->path)
|
|
goto out_dev;
|
|
connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
|
|
logptr->system_service, NULL, NULL,
|
|
logptr);
|
|
if (connect_rc) {
|
|
pr_err("vmlogrdr: iucv connection to %s "
|
|
"failed with rc %i \n",
|
|
logptr->system_service, connect_rc);
|
|
goto out_path;
|
|
}
|
|
|
|
/* We've issued the connect and now we must wait for a
|
|
* ConnectionComplete or ConnectinSevered Interrupt
|
|
* before we can continue to process.
|
|
*/
|
|
wait_event(conn_wait_queue, (logptr->connection_established)
|
|
|| (logptr->iucv_path_severed));
|
|
if (logptr->iucv_path_severed)
|
|
goto out_record;
|
|
nonseekable_open(inode, filp);
|
|
return 0;
|
|
|
|
out_record:
|
|
if (logptr->autorecording)
|
|
vmlogrdr_recording(logptr,0,logptr->autopurge);
|
|
out_path:
|
|
kfree(logptr->path); /* kfree(NULL) is ok. */
|
|
logptr->path = NULL;
|
|
out_dev:
|
|
logptr->dev_in_use = 0;
|
|
return -EIO;
|
|
}
|
|
|
|
|
|
static int vmlogrdr_release (struct inode *inode, struct file *filp)
|
|
{
|
|
int ret;
|
|
|
|
struct vmlogrdr_priv_t * logptr = filp->private_data;
|
|
|
|
iucv_path_sever(logptr->path, NULL);
|
|
kfree(logptr->path);
|
|
logptr->path = NULL;
|
|
if (logptr->autorecording) {
|
|
ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
|
|
if (ret)
|
|
pr_warning("vmlogrdr: failed to stop "
|
|
"recording automatically\n");
|
|
}
|
|
logptr->dev_in_use = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int vmlogrdr_receive_data(struct vmlogrdr_priv_t *priv)
|
|
{
|
|
int rc, *temp;
|
|
/* we need to keep track of two data sizes here:
|
|
* The number of bytes we need to receive from iucv and
|
|
* the total number of bytes we actually write into the buffer.
|
|
*/
|
|
int user_data_count, iucv_data_count;
|
|
char * buffer;
|
|
|
|
if (atomic_read(&priv->receive_ready)) {
|
|
spin_lock_bh(&priv->priv_lock);
|
|
if (priv->residual_length){
|
|
/* receive second half of a record */
|
|
iucv_data_count = priv->residual_length;
|
|
user_data_count = 0;
|
|
buffer = priv->buffer;
|
|
} else {
|
|
/* receive a new record:
|
|
* We need to return the total length of the record
|
|
* + size of FENCE in the first 4 bytes of the buffer.
|
|
*/
|
|
iucv_data_count = priv->local_interrupt_buffer.length;
|
|
user_data_count = sizeof(int);
|
|
temp = (int*)priv->buffer;
|
|
*temp= iucv_data_count + sizeof(FENCE);
|
|
buffer = priv->buffer + sizeof(int);
|
|
}
|
|
/*
|
|
* If the record is bigger than our buffer, we receive only
|
|
* a part of it. We can get the rest later.
|
|
*/
|
|
if (iucv_data_count > NET_BUFFER_SIZE)
|
|
iucv_data_count = NET_BUFFER_SIZE;
|
|
rc = iucv_message_receive(priv->path,
|
|
&priv->local_interrupt_buffer,
|
|
0, buffer, iucv_data_count,
|
|
&priv->residual_length);
|
|
spin_unlock_bh(&priv->priv_lock);
|
|
/* An rc of 5 indicates that the record was bigger than
|
|
* the buffer, which is OK for us. A 9 indicates that the
|
|
* record was purged befor we could receive it.
|
|
*/
|
|
if (rc == 5)
|
|
rc = 0;
|
|
if (rc == 9)
|
|
atomic_set(&priv->receive_ready, 0);
|
|
} else {
|
|
rc = 1;
|
|
}
|
|
if (!rc) {
|
|
priv->buffer_free = 0;
|
|
user_data_count += iucv_data_count;
|
|
priv->current_position = priv->buffer;
|
|
if (priv->residual_length == 0){
|
|
/* the whole record has been captured,
|
|
* now add the fence */
|
|
atomic_dec(&priv->receive_ready);
|
|
buffer = priv->buffer + user_data_count;
|
|
memcpy(buffer, FENCE, sizeof(FENCE));
|
|
user_data_count += sizeof(FENCE);
|
|
}
|
|
priv->remaining = user_data_count;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
static ssize_t vmlogrdr_read(struct file *filp, char __user *data,
|
|
size_t count, loff_t * ppos)
|
|
{
|
|
int rc;
|
|
struct vmlogrdr_priv_t * priv = filp->private_data;
|
|
|
|
while (priv->buffer_free) {
|
|
rc = vmlogrdr_receive_data(priv);
|
|
if (rc) {
|
|
rc = wait_event_interruptible(read_wait_queue,
|
|
atomic_read(&priv->receive_ready));
|
|
if (rc)
|
|
return rc;
|
|
}
|
|
}
|
|
/* copy only up to end of record */
|
|
if (count > priv->remaining)
|
|
count = priv->remaining;
|
|
|
|
if (copy_to_user(data, priv->current_position, count))
|
|
return -EFAULT;
|
|
|
|
*ppos += count;
|
|
priv->current_position += count;
|
|
priv->remaining -= count;
|
|
|
|
/* if all data has been transferred, set buffer free */
|
|
if (priv->remaining == 0)
|
|
priv->buffer_free = 1;
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t vmlogrdr_autopurge_store(struct device * dev,
|
|
struct device_attribute *attr,
|
|
const char * buf, size_t count)
|
|
{
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
ssize_t ret = count;
|
|
|
|
switch (buf[0]) {
|
|
case '0':
|
|
priv->autopurge=0;
|
|
break;
|
|
case '1':
|
|
priv->autopurge=1;
|
|
break;
|
|
default:
|
|
ret = -EINVAL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static ssize_t vmlogrdr_autopurge_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
return sprintf(buf, "%u\n", priv->autopurge);
|
|
}
|
|
|
|
|
|
static DEVICE_ATTR(autopurge, 0644, vmlogrdr_autopurge_show,
|
|
vmlogrdr_autopurge_store);
|
|
|
|
|
|
static ssize_t vmlogrdr_purge_store(struct device * dev,
|
|
struct device_attribute *attr,
|
|
const char * buf, size_t count)
|
|
{
|
|
|
|
char cp_command[80];
|
|
char cp_response[80];
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
|
|
if (buf[0] != '1')
|
|
return -EINVAL;
|
|
|
|
memset(cp_command, 0x00, sizeof(cp_command));
|
|
memset(cp_response, 0x00, sizeof(cp_response));
|
|
|
|
/*
|
|
* The recording command needs to be called with option QID
|
|
* for guests that have previlege classes A or B.
|
|
* Other guests will not recognize the command and we have to
|
|
* issue the same command without the QID parameter.
|
|
*/
|
|
|
|
if (recording_class_AB)
|
|
snprintf(cp_command, sizeof(cp_command),
|
|
"RECORDING %s PURGE QID * ",
|
|
priv->recording_name);
|
|
else
|
|
snprintf(cp_command, sizeof(cp_command),
|
|
"RECORDING %s PURGE ",
|
|
priv->recording_name);
|
|
|
|
cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
static DEVICE_ATTR(purge, 0200, NULL, vmlogrdr_purge_store);
|
|
|
|
|
|
static ssize_t vmlogrdr_autorecording_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
ssize_t ret = count;
|
|
|
|
switch (buf[0]) {
|
|
case '0':
|
|
priv->autorecording=0;
|
|
break;
|
|
case '1':
|
|
priv->autorecording=1;
|
|
break;
|
|
default:
|
|
ret = -EINVAL;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static ssize_t vmlogrdr_autorecording_show(struct device *dev,
|
|
struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
return sprintf(buf, "%u\n", priv->autorecording);
|
|
}
|
|
|
|
|
|
static DEVICE_ATTR(autorecording, 0644, vmlogrdr_autorecording_show,
|
|
vmlogrdr_autorecording_store);
|
|
|
|
|
|
static ssize_t vmlogrdr_recording_store(struct device * dev,
|
|
struct device_attribute *attr,
|
|
const char * buf, size_t count)
|
|
{
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
ssize_t ret;
|
|
|
|
switch (buf[0]) {
|
|
case '0':
|
|
ret = vmlogrdr_recording(priv,0,0);
|
|
break;
|
|
case '1':
|
|
ret = vmlogrdr_recording(priv,1,0);
|
|
break;
|
|
default:
|
|
ret = -EINVAL;
|
|
}
|
|
if (ret)
|
|
return ret;
|
|
else
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
static DEVICE_ATTR(recording, 0200, NULL, vmlogrdr_recording_store);
|
|
|
|
|
|
static ssize_t vmlogrdr_recording_status_show(struct device_driver *driver,
|
|
char *buf)
|
|
{
|
|
|
|
char cp_command[] = "QUERY RECORDING ";
|
|
int len;
|
|
|
|
cpcmd(cp_command, buf, 4096, NULL);
|
|
len = strlen(buf);
|
|
return len;
|
|
}
|
|
|
|
|
|
static DRIVER_ATTR(recording_status, 0444, vmlogrdr_recording_status_show,
|
|
NULL);
|
|
|
|
static struct attribute *vmlogrdr_attrs[] = {
|
|
&dev_attr_autopurge.attr,
|
|
&dev_attr_purge.attr,
|
|
&dev_attr_autorecording.attr,
|
|
&dev_attr_recording.attr,
|
|
NULL,
|
|
};
|
|
|
|
static int vmlogrdr_pm_prepare(struct device *dev)
|
|
{
|
|
int rc;
|
|
struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
|
|
|
|
rc = 0;
|
|
if (priv) {
|
|
spin_lock_bh(&priv->priv_lock);
|
|
if (priv->dev_in_use)
|
|
rc = -EBUSY;
|
|
spin_unlock_bh(&priv->priv_lock);
|
|
}
|
|
if (rc)
|
|
pr_err("vmlogrdr: device %s is busy. Refuse to suspend.\n",
|
|
dev_name(dev));
|
|
return rc;
|
|
}
|
|
|
|
|
|
static const struct dev_pm_ops vmlogrdr_pm_ops = {
|
|
.prepare = vmlogrdr_pm_prepare,
|
|
};
|
|
|
|
static struct attribute_group vmlogrdr_attr_group = {
|
|
.attrs = vmlogrdr_attrs,
|
|
};
|
|
|
|
static struct class *vmlogrdr_class;
|
|
static struct device_driver vmlogrdr_driver = {
|
|
.name = "vmlogrdr",
|
|
.bus = &iucv_bus,
|
|
.pm = &vmlogrdr_pm_ops,
|
|
};
|
|
|
|
|
|
static int vmlogrdr_register_driver(void)
|
|
{
|
|
int ret;
|
|
|
|
/* Register with iucv driver */
|
|
ret = iucv_register(&vmlogrdr_iucv_handler, 1);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = driver_register(&vmlogrdr_driver);
|
|
if (ret)
|
|
goto out_iucv;
|
|
|
|
ret = driver_create_file(&vmlogrdr_driver,
|
|
&driver_attr_recording_status);
|
|
if (ret)
|
|
goto out_driver;
|
|
|
|
vmlogrdr_class = class_create(THIS_MODULE, "vmlogrdr");
|
|
if (IS_ERR(vmlogrdr_class)) {
|
|
ret = PTR_ERR(vmlogrdr_class);
|
|
vmlogrdr_class = NULL;
|
|
goto out_attr;
|
|
}
|
|
return 0;
|
|
|
|
out_attr:
|
|
driver_remove_file(&vmlogrdr_driver, &driver_attr_recording_status);
|
|
out_driver:
|
|
driver_unregister(&vmlogrdr_driver);
|
|
out_iucv:
|
|
iucv_unregister(&vmlogrdr_iucv_handler, 1);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void vmlogrdr_unregister_driver(void)
|
|
{
|
|
class_destroy(vmlogrdr_class);
|
|
vmlogrdr_class = NULL;
|
|
driver_remove_file(&vmlogrdr_driver, &driver_attr_recording_status);
|
|
driver_unregister(&vmlogrdr_driver);
|
|
iucv_unregister(&vmlogrdr_iucv_handler, 1);
|
|
}
|
|
|
|
|
|
static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
|
|
{
|
|
struct device *dev;
|
|
int ret;
|
|
|
|
dev = kzalloc(sizeof(struct device), GFP_KERNEL);
|
|
if (dev) {
|
|
dev_set_name(dev, priv->internal_name);
|
|
dev->bus = &iucv_bus;
|
|
dev->parent = iucv_root;
|
|
dev->driver = &vmlogrdr_driver;
|
|
dev_set_drvdata(dev, priv);
|
|
/*
|
|
* The release function could be called after the
|
|
* module has been unloaded. It's _only_ task is to
|
|
* free the struct. Therefore, we specify kfree()
|
|
* directly here. (Probably a little bit obfuscating
|
|
* but legitime ...).
|
|
*/
|
|
dev->release = (void (*)(struct device *))kfree;
|
|
} else
|
|
return -ENOMEM;
|
|
ret = device_register(dev);
|
|
if (ret) {
|
|
put_device(dev);
|
|
return ret;
|
|
}
|
|
|
|
ret = sysfs_create_group(&dev->kobj, &vmlogrdr_attr_group);
|
|
if (ret) {
|
|
device_unregister(dev);
|
|
return ret;
|
|
}
|
|
priv->class_device = device_create(vmlogrdr_class, dev,
|
|
MKDEV(vmlogrdr_major,
|
|
priv->minor_num),
|
|
priv, "%s", dev_name(dev));
|
|
if (IS_ERR(priv->class_device)) {
|
|
ret = PTR_ERR(priv->class_device);
|
|
priv->class_device=NULL;
|
|
sysfs_remove_group(&dev->kobj, &vmlogrdr_attr_group);
|
|
device_unregister(dev);
|
|
return ret;
|
|
}
|
|
priv->device = dev;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
|
|
{
|
|
device_destroy(vmlogrdr_class, MKDEV(vmlogrdr_major, priv->minor_num));
|
|
if (priv->device != NULL) {
|
|
sysfs_remove_group(&priv->device->kobj, &vmlogrdr_attr_group);
|
|
device_unregister(priv->device);
|
|
priv->device=NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int vmlogrdr_register_cdev(dev_t dev)
|
|
{
|
|
int rc = 0;
|
|
vmlogrdr_cdev = cdev_alloc();
|
|
if (!vmlogrdr_cdev) {
|
|
return -ENOMEM;
|
|
}
|
|
vmlogrdr_cdev->owner = THIS_MODULE;
|
|
vmlogrdr_cdev->ops = &vmlogrdr_fops;
|
|
vmlogrdr_cdev->dev = dev;
|
|
rc = cdev_add(vmlogrdr_cdev, vmlogrdr_cdev->dev, MAXMINOR);
|
|
if (!rc)
|
|
return 0;
|
|
|
|
// cleanup: cdev is not fully registered, no cdev_del here!
|
|
kobject_put(&vmlogrdr_cdev->kobj);
|
|
vmlogrdr_cdev=NULL;
|
|
return rc;
|
|
}
|
|
|
|
|
|
static void vmlogrdr_cleanup(void)
|
|
{
|
|
int i;
|
|
|
|
if (vmlogrdr_cdev) {
|
|
cdev_del(vmlogrdr_cdev);
|
|
vmlogrdr_cdev=NULL;
|
|
}
|
|
for (i=0; i < MAXMINOR; ++i ) {
|
|
vmlogrdr_unregister_device(&sys_ser[i]);
|
|
free_page((unsigned long)sys_ser[i].buffer);
|
|
}
|
|
vmlogrdr_unregister_driver();
|
|
if (vmlogrdr_major) {
|
|
unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);
|
|
vmlogrdr_major=0;
|
|
}
|
|
}
|
|
|
|
|
|
static int __init vmlogrdr_init(void)
|
|
{
|
|
int rc;
|
|
int i;
|
|
dev_t dev;
|
|
|
|
if (! MACHINE_IS_VM) {
|
|
pr_err("not running under VM, driver not loaded.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
recording_class_AB = vmlogrdr_get_recording_class_AB();
|
|
|
|
rc = alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
|
|
if (rc)
|
|
return rc;
|
|
vmlogrdr_major = MAJOR(dev);
|
|
|
|
rc=vmlogrdr_register_driver();
|
|
if (rc)
|
|
goto cleanup;
|
|
|
|
for (i=0; i < MAXMINOR; ++i ) {
|
|
sys_ser[i].buffer = (char *) get_zeroed_page(GFP_KERNEL);
|
|
if (!sys_ser[i].buffer) {
|
|
rc = -ENOMEM;
|
|
break;
|
|
}
|
|
sys_ser[i].current_position = sys_ser[i].buffer;
|
|
rc=vmlogrdr_register_device(&sys_ser[i]);
|
|
if (rc)
|
|
break;
|
|
}
|
|
if (rc)
|
|
goto cleanup;
|
|
|
|
rc = vmlogrdr_register_cdev(dev);
|
|
if (rc)
|
|
goto cleanup;
|
|
return 0;
|
|
|
|
cleanup:
|
|
vmlogrdr_cleanup();
|
|
return rc;
|
|
}
|
|
|
|
|
|
static void __exit vmlogrdr_exit(void)
|
|
{
|
|
vmlogrdr_cleanup();
|
|
return;
|
|
}
|
|
|
|
|
|
module_init(vmlogrdr_init);
|
|
module_exit(vmlogrdr_exit);
|