2010-01-18 13:44:55 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
|
2009-12-21 15:33:25 +00:00
|
|
|
* Copyright (C) 2009, 2010 Red Hat, Inc.
|
2007-10-22 01:03:39 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
2009-12-21 16:06:04 +00:00
|
|
|
#include <linux/cdev.h>
|
2009-12-21 17:06:21 +00:00
|
|
|
#include <linux/debugfs.h>
|
2009-12-21 16:06:04 +00:00
|
|
|
#include <linux/device.h>
|
2007-10-22 01:03:39 +00:00
|
|
|
#include <linux/err.h>
|
2009-12-21 16:19:30 +00:00
|
|
|
#include <linux/fs.h>
|
2007-10-22 01:03:39 +00:00
|
|
|
#include <linux/init.h>
|
2010-01-18 13:45:05 +00:00
|
|
|
#include <linux/list.h>
|
2009-12-21 16:19:30 +00:00
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/sched.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
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>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2010-01-18 13:45:05 +00:00
|
|
|
#include <linux/spinlock.h>
|
2007-10-22 01:03:39 +00:00
|
|
|
#include <linux/virtio.h>
|
|
|
|
#include <linux/virtio_console.h>
|
2009-12-21 16:19:30 +00:00
|
|
|
#include <linux/wait.h>
|
2009-12-21 15:33:25 +00:00
|
|
|
#include <linux/workqueue.h>
|
2007-10-22 01:03:39 +00:00
|
|
|
#include "hvc_console.h"
|
|
|
|
|
2010-01-18 13:45:05 +00:00
|
|
|
/*
|
|
|
|
* This is a global struct for storing common data for all the devices
|
|
|
|
* this driver handles.
|
|
|
|
*
|
|
|
|
* Mainly, it has a linked list for all the consoles in one place so
|
|
|
|
* that callbacks from hvc for get_chars(), put_chars() work properly
|
|
|
|
* across multiple devices and multiple ports per device.
|
|
|
|
*/
|
|
|
|
struct ports_driver_data {
|
2009-12-21 16:06:04 +00:00
|
|
|
/* Used for registering chardevs */
|
|
|
|
struct class *class;
|
|
|
|
|
2009-12-21 17:06:21 +00:00
|
|
|
/* Used for exporting per-port information to debugfs */
|
|
|
|
struct dentry *debugfs_dir;
|
|
|
|
|
2010-09-02 12:41:49 +00:00
|
|
|
/* List of all the devices we're handling */
|
|
|
|
struct list_head portdevs;
|
|
|
|
|
2009-12-21 16:06:04 +00:00
|
|
|
/* Number of devices this driver is handling */
|
|
|
|
unsigned int index;
|
|
|
|
|
2010-01-18 13:45:06 +00:00
|
|
|
/*
|
|
|
|
* This is used to keep track of the number of hvc consoles
|
|
|
|
* spawned by this driver. This number is given as the first
|
|
|
|
* argument to hvc_alloc(). To correctly map an initial
|
|
|
|
* console spawned via hvc_instantiate to the console being
|
|
|
|
* hooked up via hvc_alloc, we need to pass the same vtermno.
|
|
|
|
*
|
|
|
|
* We also just assume the first console being initialised was
|
|
|
|
* the first one that got used as the initial console.
|
|
|
|
*/
|
|
|
|
unsigned int next_vtermno;
|
|
|
|
|
2010-01-18 13:45:05 +00:00
|
|
|
/* All the console devices handled by this driver */
|
|
|
|
struct list_head consoles;
|
|
|
|
};
|
|
|
|
static struct ports_driver_data pdrvdata;
|
|
|
|
|
|
|
|
DEFINE_SPINLOCK(pdrvdata_lock);
|
|
|
|
|
2010-01-18 13:45:09 +00:00
|
|
|
/* This struct holds information that's relevant only for console ports */
|
|
|
|
struct console {
|
|
|
|
/* We'll place all consoles in a list in the pdrvdata struct */
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
/* The hvc device associated with this console port */
|
|
|
|
struct hvc_struct *hvc;
|
|
|
|
|
2010-05-05 20:35:08 +00:00
|
|
|
/* The size of the console */
|
|
|
|
struct winsize ws;
|
|
|
|
|
2010-01-18 13:45:09 +00:00
|
|
|
/*
|
|
|
|
* This number identifies the number that we used to register
|
|
|
|
* with hvc in hvc_instantiate() and hvc_alloc(); this is the
|
|
|
|
* number passed on by the hvc callbacks to us to
|
|
|
|
* differentiate between the other console ports handled by
|
|
|
|
* this driver
|
|
|
|
*/
|
|
|
|
u32 vtermno;
|
|
|
|
};
|
|
|
|
|
2010-01-18 13:45:01 +00:00
|
|
|
struct port_buffer {
|
|
|
|
char *buf;
|
|
|
|
|
|
|
|
/* size of the buffer in *buf above */
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
/* used length of the buffer */
|
|
|
|
size_t len;
|
|
|
|
/* offset in the buf from which to consume data */
|
|
|
|
size_t offset;
|
|
|
|
};
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
/*
|
|
|
|
* This is a per-device struct that stores data common to all the
|
|
|
|
* ports for that device (vdev->priv).
|
|
|
|
*/
|
|
|
|
struct ports_device {
|
2010-09-02 12:41:49 +00:00
|
|
|
/* Next portdev in the list, head is in the pdrvdata struct */
|
|
|
|
struct list_head list;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
/*
|
|
|
|
* Workqueue handlers where we process deferred work after
|
|
|
|
* notification
|
|
|
|
*/
|
|
|
|
struct work_struct control_work;
|
|
|
|
|
|
|
|
struct list_head ports;
|
|
|
|
|
|
|
|
/* To protect the list of ports */
|
|
|
|
spinlock_t ports_lock;
|
|
|
|
|
|
|
|
/* To protect the vq operations for the control channel */
|
|
|
|
spinlock_t cvq_lock;
|
|
|
|
|
|
|
|
/* The current config space is stored here */
|
2010-05-20 04:15:46 +00:00
|
|
|
struct virtio_console_config config;
|
2009-12-21 15:33:25 +00:00
|
|
|
|
|
|
|
/* The virtio device we're associated with */
|
|
|
|
struct virtio_device *vdev;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A couple of virtqueues for the control channel: one for
|
|
|
|
* guest->host transfers, one for host->guest transfers
|
|
|
|
*/
|
|
|
|
struct virtqueue *c_ivq, *c_ovq;
|
|
|
|
|
|
|
|
/* Array of per-port IO virtqueues */
|
|
|
|
struct virtqueue **in_vqs, **out_vqs;
|
2009-12-21 16:06:04 +00:00
|
|
|
|
|
|
|
/* Used for numbering devices for sysfs and debugfs */
|
|
|
|
unsigned int drv_index;
|
|
|
|
|
|
|
|
/* Major number for this device. Ports will be created as minors. */
|
|
|
|
int chr_major;
|
2009-12-21 15:33:25 +00:00
|
|
|
};
|
|
|
|
|
2010-01-18 13:45:07 +00:00
|
|
|
/* This struct holds the per-port data */
|
2010-01-18 13:45:00 +00:00
|
|
|
struct port {
|
2009-12-21 15:33:25 +00:00
|
|
|
/* Next port in the list, head is in the ports_device */
|
|
|
|
struct list_head list;
|
|
|
|
|
2010-01-18 13:45:07 +00:00
|
|
|
/* Pointer to the parent virtio_console device */
|
|
|
|
struct ports_device *portdev;
|
2010-01-18 13:45:01 +00:00
|
|
|
|
|
|
|
/* The current buffer from which data has to be fed to readers */
|
|
|
|
struct port_buffer *inbuf;
|
2010-01-18 13:45:00 +00:00
|
|
|
|
2010-01-18 13:45:12 +00:00
|
|
|
/*
|
|
|
|
* To protect the operations on the in_vq associated with this
|
|
|
|
* port. Has to be a spinlock because it can be called from
|
|
|
|
* interrupt context (get_char()).
|
|
|
|
*/
|
|
|
|
spinlock_t inbuf_lock;
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
/* Protect the operations on the out_vq. */
|
|
|
|
spinlock_t outvq_lock;
|
|
|
|
|
2010-01-18 13:45:07 +00:00
|
|
|
/* The IO vqs for this port */
|
|
|
|
struct virtqueue *in_vq, *out_vq;
|
|
|
|
|
2009-12-21 17:06:21 +00:00
|
|
|
/* File in the debugfs directory that exposes this port's information */
|
|
|
|
struct dentry *debugfs_file;
|
|
|
|
|
2010-01-18 13:45:09 +00:00
|
|
|
/*
|
|
|
|
* The entries in this struct will be valid if this port is
|
|
|
|
* hooked up to an hvc console
|
|
|
|
*/
|
|
|
|
struct console cons;
|
2009-12-21 15:33:25 +00:00
|
|
|
|
2009-12-21 16:06:04 +00:00
|
|
|
/* Each port associates with a separate char device */
|
|
|
|
struct cdev cdev;
|
|
|
|
struct device *dev;
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
/* A waitqueue for poll() or blocking read operations */
|
|
|
|
wait_queue_head_t waitqueue;
|
|
|
|
|
2009-12-21 16:27:40 +00:00
|
|
|
/* The 'name' of the port that we expose via sysfs properties */
|
|
|
|
char *name;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
/* The 'id' to identify the port with the Host */
|
|
|
|
u32 id;
|
2009-12-21 16:19:30 +00:00
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
bool outvq_full;
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
/* Is the host device open */
|
|
|
|
bool host_connected;
|
2009-11-26 05:55:38 +00:00
|
|
|
|
|
|
|
/* We should allow only one process to open a port */
|
|
|
|
bool guest_connected;
|
2010-01-18 13:45:00 +00:00
|
|
|
};
|
2007-10-22 01:03:39 +00:00
|
|
|
|
2010-01-18 13:44:56 +00:00
|
|
|
/* This is the very early arch-specified put chars function. */
|
|
|
|
static int (*early_put_chars)(u32, const char *, int);
|
|
|
|
|
2010-01-18 13:45:05 +00:00
|
|
|
static struct port *find_port_by_vtermno(u32 vtermno)
|
|
|
|
{
|
|
|
|
struct port *port;
|
2010-01-18 13:45:09 +00:00
|
|
|
struct console *cons;
|
2010-01-18 13:45:05 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&pdrvdata_lock, flags);
|
2010-01-18 13:45:09 +00:00
|
|
|
list_for_each_entry(cons, &pdrvdata.consoles, list) {
|
|
|
|
if (cons->vtermno == vtermno) {
|
|
|
|
port = container_of(cons, struct port, cons);
|
2010-01-18 13:45:05 +00:00
|
|
|
goto out;
|
2010-01-18 13:45:09 +00:00
|
|
|
}
|
2010-01-18 13:45:05 +00:00
|
|
|
}
|
|
|
|
port = NULL;
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&pdrvdata_lock, flags);
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&portdev->ports_lock, flags);
|
|
|
|
list_for_each_entry(port, &portdev->ports, list)
|
|
|
|
if (port->id == id)
|
|
|
|
goto out;
|
|
|
|
port = NULL;
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&portdev->ports_lock, flags);
|
|
|
|
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:12 +00:00
|
|
|
static struct port *find_port_by_vq(struct ports_device *portdev,
|
|
|
|
struct virtqueue *vq)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
spin_lock_irqsave(&portdev->ports_lock, flags);
|
|
|
|
list_for_each_entry(port, &portdev->ports, list)
|
2010-01-18 13:45:12 +00:00
|
|
|
if (port->in_vq == vq || port->out_vq == vq)
|
|
|
|
goto out;
|
|
|
|
port = NULL;
|
|
|
|
out:
|
2009-12-21 15:33:25 +00:00
|
|
|
spin_unlock_irqrestore(&portdev->ports_lock, flags);
|
2010-01-18 13:45:12 +00:00
|
|
|
return port;
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
static bool is_console_port(struct port *port)
|
|
|
|
{
|
|
|
|
if (port->cons.hvc)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool use_multiport(struct ports_device *portdev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This condition can be true when put_chars is called from
|
|
|
|
* early_init
|
|
|
|
*/
|
|
|
|
if (!portdev->vdev)
|
|
|
|
return 0;
|
|
|
|
return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
|
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:01 +00:00
|
|
|
static void free_buf(struct port_buffer *buf)
|
|
|
|
{
|
|
|
|
kfree(buf->buf);
|
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct port_buffer *alloc_buf(size_t buf_size)
|
|
|
|
{
|
|
|
|
struct port_buffer *buf;
|
|
|
|
|
|
|
|
buf = kmalloc(sizeof(*buf), GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
goto fail;
|
|
|
|
buf->buf = kzalloc(buf_size, GFP_KERNEL);
|
|
|
|
if (!buf->buf)
|
|
|
|
goto free_buf;
|
|
|
|
buf->len = 0;
|
|
|
|
buf->offset = 0;
|
|
|
|
buf->size = buf_size;
|
|
|
|
return buf;
|
|
|
|
|
|
|
|
free_buf:
|
|
|
|
kfree(buf);
|
|
|
|
fail:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:03 +00:00
|
|
|
/* Callers should take appropriate locks */
|
|
|
|
static void *get_inbuf(struct port *port)
|
|
|
|
{
|
|
|
|
struct port_buffer *buf;
|
|
|
|
struct virtqueue *vq;
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
vq = port->in_vq;
|
2010-04-12 13:18:32 +00:00
|
|
|
buf = virtqueue_get_buf(vq, &len);
|
2010-01-18 13:45:03 +00:00
|
|
|
if (buf) {
|
|
|
|
buf->len = len;
|
|
|
|
buf->offset = 0;
|
|
|
|
}
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:02 +00:00
|
|
|
/*
|
|
|
|
* Create a scatter-gather list representing our input buffer and put
|
|
|
|
* it in the queue.
|
|
|
|
*
|
|
|
|
* Callers should take appropriate locks.
|
|
|
|
*/
|
2010-01-18 13:45:12 +00:00
|
|
|
static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
|
2010-01-18 13:45:02 +00:00
|
|
|
{
|
|
|
|
struct scatterlist sg[1];
|
2010-01-18 13:45:12 +00:00
|
|
|
int ret;
|
2010-01-18 13:45:07 +00:00
|
|
|
|
2010-01-18 13:45:02 +00:00
|
|
|
sg_init_one(sg, buf->buf, buf->size);
|
|
|
|
|
2010-04-12 13:18:32 +00:00
|
|
|
ret = virtqueue_add_buf(vq, sg, 0, 1, buf);
|
|
|
|
virtqueue_kick(vq);
|
2010-01-18 13:45:12 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:45:30 +00:00
|
|
|
/* Discard any unread data this port has. Callers lockers. */
|
|
|
|
static void discard_port_data(struct port *port)
|
|
|
|
{
|
|
|
|
struct port_buffer *buf;
|
|
|
|
struct virtqueue *vq;
|
|
|
|
unsigned int len;
|
2010-02-12 05:02:18 +00:00
|
|
|
int ret;
|
2009-12-21 16:45:30 +00:00
|
|
|
|
|
|
|
vq = port->in_vq;
|
|
|
|
if (port->inbuf)
|
|
|
|
buf = port->inbuf;
|
|
|
|
else
|
2010-04-12 13:18:32 +00:00
|
|
|
buf = virtqueue_get_buf(vq, &len);
|
2009-12-21 16:45:30 +00:00
|
|
|
|
2010-02-12 05:02:18 +00:00
|
|
|
ret = 0;
|
|
|
|
while (buf) {
|
|
|
|
if (add_inbuf(vq, buf) < 0) {
|
|
|
|
ret++;
|
|
|
|
free_buf(buf);
|
|
|
|
}
|
2010-04-12 13:18:32 +00:00
|
|
|
buf = virtqueue_get_buf(vq, &len);
|
2009-12-21 16:45:30 +00:00
|
|
|
}
|
|
|
|
port->inbuf = NULL;
|
2010-02-12 05:02:18 +00:00
|
|
|
if (ret)
|
|
|
|
dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
|
|
|
|
ret);
|
2009-12-21 16:45:30 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:12 +00:00
|
|
|
static bool port_has_data(struct port *port)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
bool ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->inbuf_lock, flags);
|
2010-02-12 05:02:18 +00:00
|
|
|
if (port->inbuf) {
|
2010-01-18 13:45:12 +00:00
|
|
|
ret = true;
|
2010-02-12 05:02:18 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
port->inbuf = get_inbuf(port);
|
|
|
|
if (port->inbuf) {
|
|
|
|
ret = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
ret = false;
|
|
|
|
out:
|
2010-01-18 13:45:12 +00:00
|
|
|
spin_unlock_irqrestore(&port->inbuf_lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-05-20 04:15:46 +00:00
|
|
|
static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
|
|
|
|
unsigned int event, unsigned int value)
|
2009-12-21 15:33:25 +00:00
|
|
|
{
|
|
|
|
struct scatterlist sg[1];
|
|
|
|
struct virtio_console_control cpkt;
|
|
|
|
struct virtqueue *vq;
|
2010-02-24 05:06:51 +00:00
|
|
|
unsigned int len;
|
2009-12-21 15:33:25 +00:00
|
|
|
|
2010-05-20 04:15:46 +00:00
|
|
|
if (!use_multiport(portdev))
|
2009-12-21 15:33:25 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-05-20 04:15:46 +00:00
|
|
|
cpkt.id = port_id;
|
2009-12-21 15:33:25 +00:00
|
|
|
cpkt.event = event;
|
|
|
|
cpkt.value = value;
|
|
|
|
|
2010-05-20 04:15:46 +00:00
|
|
|
vq = portdev->c_ovq;
|
2009-12-21 15:33:25 +00:00
|
|
|
|
|
|
|
sg_init_one(sg, &cpkt, sizeof(cpkt));
|
2010-04-12 13:18:32 +00:00
|
|
|
if (virtqueue_add_buf(vq, sg, 1, 0, &cpkt) >= 0) {
|
|
|
|
virtqueue_kick(vq);
|
|
|
|
while (!virtqueue_get_buf(vq, &len))
|
2009-12-21 15:33:25 +00:00
|
|
|
cpu_relax();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-20 04:15:46 +00:00
|
|
|
static ssize_t send_control_msg(struct port *port, unsigned int event,
|
|
|
|
unsigned int value)
|
|
|
|
{
|
2010-09-02 12:41:42 +00:00
|
|
|
/* Did the port get unplugged before userspace closed it? */
|
|
|
|
if (port->portdev)
|
|
|
|
return __send_control_msg(port->portdev, port->id, event, value);
|
|
|
|
return 0;
|
2010-05-20 04:15:46 +00:00
|
|
|
}
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
/* Callers must take the port->outvq_lock */
|
|
|
|
static void reclaim_consumed_buffers(struct port *port)
|
|
|
|
{
|
|
|
|
void *buf;
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
while ((buf = virtqueue_get_buf(port->out_vq, &len))) {
|
|
|
|
kfree(buf);
|
|
|
|
port->outvq_full = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
|
|
|
|
bool nonblock)
|
2009-12-21 11:58:51 +00:00
|
|
|
{
|
|
|
|
struct scatterlist sg[1];
|
|
|
|
struct virtqueue *out_vq;
|
|
|
|
ssize_t ret;
|
2010-05-20 04:15:50 +00:00
|
|
|
unsigned long flags;
|
2009-12-21 11:58:51 +00:00
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
out_vq = port->out_vq;
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
spin_lock_irqsave(&port->outvq_lock, flags);
|
|
|
|
|
|
|
|
reclaim_consumed_buffers(port);
|
|
|
|
|
2009-12-21 11:58:51 +00:00
|
|
|
sg_init_one(sg, in_buf, in_count);
|
2010-04-12 13:18:32 +00:00
|
|
|
ret = virtqueue_add_buf(out_vq, sg, 1, 0, in_buf);
|
2009-12-21 11:58:51 +00:00
|
|
|
|
|
|
|
/* Tell Host to go! */
|
2010-04-12 13:18:32 +00:00
|
|
|
virtqueue_kick(out_vq);
|
2009-12-21 11:58:51 +00:00
|
|
|
|
|
|
|
if (ret < 0) {
|
2010-04-08 15:46:16 +00:00
|
|
|
in_count = 0;
|
2010-05-20 04:15:50 +00:00
|
|
|
goto done;
|
2009-12-21 11:58:51 +00:00
|
|
|
}
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
if (ret == 0)
|
|
|
|
port->outvq_full = true;
|
|
|
|
|
|
|
|
if (nonblock)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait till the host acknowledges it pushed out the data we
|
2010-10-20 03:15:43 +00:00
|
|
|
* sent. This is done for data from the hvc_console; the tty
|
|
|
|
* operations are performed with spinlocks held so we can't
|
|
|
|
* sleep here. An alternative would be to copy the data to a
|
|
|
|
* buffer and relax the spinning requirement. The downside is
|
|
|
|
* we need to kmalloc a GFP_ATOMIC buffer each time the
|
|
|
|
* console driver writes something out.
|
2010-05-20 04:15:50 +00:00
|
|
|
*/
|
2010-04-12 13:18:32 +00:00
|
|
|
while (!virtqueue_get_buf(out_vq, &len))
|
2009-12-21 11:58:51 +00:00
|
|
|
cpu_relax();
|
2010-05-20 04:15:50 +00:00
|
|
|
done:
|
|
|
|
spin_unlock_irqrestore(&port->outvq_lock, flags);
|
|
|
|
/*
|
|
|
|
* We're expected to return the amount of data we wrote -- all
|
|
|
|
* of it
|
|
|
|
*/
|
2010-04-08 15:46:16 +00:00
|
|
|
return in_count;
|
2009-12-21 11:58:51 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:12 +00:00
|
|
|
/*
|
|
|
|
* Give out the data that's requested from the buffer that we have
|
|
|
|
* queued up.
|
|
|
|
*/
|
2009-12-21 15:56:45 +00:00
|
|
|
static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
|
|
|
|
bool to_user)
|
2010-01-18 13:45:12 +00:00
|
|
|
{
|
|
|
|
struct port_buffer *buf;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!out_count || !port_has_data(port))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
buf = port->inbuf;
|
2009-12-21 15:56:45 +00:00
|
|
|
out_count = min(out_count, buf->len - buf->offset);
|
2010-01-18 13:45:12 +00:00
|
|
|
|
2009-12-21 15:56:45 +00:00
|
|
|
if (to_user) {
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
|
|
|
|
if (ret)
|
|
|
|
return -EFAULT;
|
|
|
|
} else {
|
|
|
|
memcpy(out_buf, buf->buf + buf->offset, out_count);
|
|
|
|
}
|
2010-01-18 13:45:12 +00:00
|
|
|
|
|
|
|
buf->offset += out_count;
|
|
|
|
|
|
|
|
if (buf->offset == buf->len) {
|
|
|
|
/*
|
|
|
|
* We're done using all the data in this buffer.
|
|
|
|
* Re-queue so that the Host can send us more data.
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&port->inbuf_lock, flags);
|
|
|
|
port->inbuf = NULL;
|
|
|
|
|
|
|
|
if (add_inbuf(port->in_vq, buf) < 0)
|
2009-12-21 16:06:04 +00:00
|
|
|
dev_warn(port->dev, "failed add_buf\n");
|
2010-01-18 13:45:12 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&port->inbuf_lock, flags);
|
|
|
|
}
|
2009-12-21 15:56:45 +00:00
|
|
|
/* Return the number of bytes actually copied */
|
2010-01-18 13:45:12 +00:00
|
|
|
return out_count;
|
2010-01-18 13:45:02 +00:00
|
|
|
}
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
/* The condition that must be true for polling to end */
|
2010-05-20 04:15:49 +00:00
|
|
|
static bool will_read_block(struct port *port)
|
2009-12-21 16:19:30 +00:00
|
|
|
{
|
2010-09-02 12:41:43 +00:00
|
|
|
if (!port->guest_connected) {
|
|
|
|
/* Port got hot-unplugged. Let's exit. */
|
|
|
|
return false;
|
|
|
|
}
|
2010-05-20 04:15:49 +00:00
|
|
|
return !port_has_data(port) && port->host_connected;
|
2009-12-21 16:19:30 +00:00
|
|
|
}
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
static bool will_write_block(struct port *port)
|
|
|
|
{
|
|
|
|
bool ret;
|
|
|
|
|
2010-05-27 07:54:40 +00:00
|
|
|
if (!port->guest_connected) {
|
|
|
|
/* Port got hot-unplugged. Let's exit. */
|
|
|
|
return false;
|
|
|
|
}
|
2010-05-20 04:15:50 +00:00
|
|
|
if (!port->host_connected)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
spin_lock_irq(&port->outvq_lock);
|
|
|
|
/*
|
|
|
|
* Check if the Host has consumed any buffers since we last
|
|
|
|
* sent data (this is only applicable for nonblocking ports).
|
|
|
|
*/
|
|
|
|
reclaim_consumed_buffers(port);
|
|
|
|
ret = port->outvq_full;
|
|
|
|
spin_unlock_irq(&port->outvq_lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
|
|
|
|
size_t count, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
port = filp->private_data;
|
|
|
|
|
|
|
|
if (!port_has_data(port)) {
|
|
|
|
/*
|
|
|
|
* If nothing's connected on the host just return 0 in
|
|
|
|
* case of list_empty; this tells the userspace app
|
|
|
|
* that there's no connection
|
|
|
|
*/
|
|
|
|
if (!port->host_connected)
|
|
|
|
return 0;
|
|
|
|
if (filp->f_flags & O_NONBLOCK)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
ret = wait_event_interruptible(port->waitqueue,
|
2010-05-20 04:15:49 +00:00
|
|
|
!will_read_block(port));
|
2009-12-21 16:19:30 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2010-09-02 12:41:45 +00:00
|
|
|
/* Port got hot-unplugged. */
|
|
|
|
if (!port->guest_connected)
|
|
|
|
return -ENODEV;
|
2009-12-21 16:19:30 +00:00
|
|
|
/*
|
|
|
|
* We could've received a disconnection message while we were
|
|
|
|
* waiting for more data.
|
|
|
|
*
|
|
|
|
* This check is not clubbed in the if() statement above as we
|
|
|
|
* might receive some data as well as the host could get
|
|
|
|
* disconnected after we got woken up from our wait. So we
|
|
|
|
* really want to give off whatever data we have and only then
|
|
|
|
* check for host_connected.
|
|
|
|
*/
|
|
|
|
if (!port_has_data(port) && !port->host_connected)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return fill_readbuf(port, ubuf, count, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
|
|
|
|
size_t count, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
char *buf;
|
|
|
|
ssize_t ret;
|
2010-05-20 04:15:50 +00:00
|
|
|
bool nonblock;
|
2009-12-21 16:19:30 +00:00
|
|
|
|
2010-09-14 07:56:16 +00:00
|
|
|
/* Userspace could be out to fool us */
|
|
|
|
if (!count)
|
|
|
|
return 0;
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
port = filp->private_data;
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
nonblock = filp->f_flags & O_NONBLOCK;
|
|
|
|
|
|
|
|
if (will_write_block(port)) {
|
|
|
|
if (nonblock)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
ret = wait_event_interruptible(port->waitqueue,
|
|
|
|
!will_write_block(port));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
2010-09-02 12:41:46 +00:00
|
|
|
/* Port got hot-unplugged. */
|
|
|
|
if (!port->guest_connected)
|
|
|
|
return -ENODEV;
|
2010-05-20 04:15:50 +00:00
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
count = min((size_t)(32 * 1024), count);
|
|
|
|
|
|
|
|
buf = kmalloc(count, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = copy_from_user(buf, ubuf, count);
|
|
|
|
if (ret) {
|
|
|
|
ret = -EFAULT;
|
|
|
|
goto free_buf;
|
|
|
|
}
|
|
|
|
|
2010-10-20 03:15:43 +00:00
|
|
|
/*
|
|
|
|
* We now ask send_buf() to not spin for generic ports -- we
|
|
|
|
* can re-use the same code path that non-blocking file
|
|
|
|
* descriptors take for blocking file descriptors since the
|
|
|
|
* wait is already done and we're certain the write will go
|
|
|
|
* through to the host.
|
|
|
|
*/
|
|
|
|
nonblock = true;
|
2010-05-20 04:15:50 +00:00
|
|
|
ret = send_buf(port, buf, count, nonblock);
|
|
|
|
|
|
|
|
if (nonblock && ret > 0)
|
|
|
|
goto out;
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
free_buf:
|
|
|
|
kfree(buf);
|
2010-05-20 04:15:50 +00:00
|
|
|
out:
|
2009-12-21 16:19:30 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
unsigned int ret;
|
|
|
|
|
|
|
|
port = filp->private_data;
|
|
|
|
poll_wait(filp, &port->waitqueue, wait);
|
|
|
|
|
2010-09-02 12:41:44 +00:00
|
|
|
if (!port->guest_connected) {
|
|
|
|
/* Port got unplugged */
|
|
|
|
return POLLHUP;
|
|
|
|
}
|
2009-12-21 16:19:30 +00:00
|
|
|
ret = 0;
|
2010-09-16 09:13:08 +00:00
|
|
|
if (!will_read_block(port))
|
2009-12-21 16:19:30 +00:00
|
|
|
ret |= POLLIN | POLLRDNORM;
|
2010-05-20 04:15:50 +00:00
|
|
|
if (!will_write_block(port))
|
2009-12-21 16:19:30 +00:00
|
|
|
ret |= POLLOUT;
|
|
|
|
if (!port->host_connected)
|
|
|
|
ret |= POLLHUP;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int port_fops_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
|
|
|
|
port = filp->private_data;
|
|
|
|
|
|
|
|
/* Notify host of port being closed */
|
|
|
|
send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
|
|
|
|
|
2009-12-21 16:45:30 +00:00
|
|
|
spin_lock_irq(&port->inbuf_lock);
|
2009-11-26 05:55:38 +00:00
|
|
|
port->guest_connected = false;
|
|
|
|
|
2009-12-21 16:45:30 +00:00
|
|
|
discard_port_data(port);
|
|
|
|
|
|
|
|
spin_unlock_irq(&port->inbuf_lock);
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
spin_lock_irq(&port->outvq_lock);
|
|
|
|
reclaim_consumed_buffers(port);
|
|
|
|
spin_unlock_irq(&port->outvq_lock);
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int port_fops_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct cdev *cdev = inode->i_cdev;
|
|
|
|
struct port *port;
|
2010-09-02 12:41:48 +00:00
|
|
|
int ret;
|
2009-12-21 16:19:30 +00:00
|
|
|
|
|
|
|
port = container_of(cdev, struct port, cdev);
|
|
|
|
filp->private_data = port;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't allow opening of console port devices -- that's done
|
|
|
|
* via /dev/hvc
|
|
|
|
*/
|
2010-09-02 12:41:48 +00:00
|
|
|
if (is_console_port(port)) {
|
|
|
|
ret = -ENXIO;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-12-21 16:19:30 +00:00
|
|
|
|
2009-11-26 05:55:38 +00:00
|
|
|
/* Allow only one process to open a particular port at a time */
|
|
|
|
spin_lock_irq(&port->inbuf_lock);
|
|
|
|
if (port->guest_connected) {
|
|
|
|
spin_unlock_irq(&port->inbuf_lock);
|
2010-09-02 12:41:48 +00:00
|
|
|
ret = -EMFILE;
|
|
|
|
goto out;
|
2009-11-26 05:55:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
port->guest_connected = true;
|
|
|
|
spin_unlock_irq(&port->inbuf_lock);
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
spin_lock_irq(&port->outvq_lock);
|
|
|
|
/*
|
|
|
|
* There might be a chance that we missed reclaiming a few
|
|
|
|
* buffers in the window of the port getting previously closed
|
|
|
|
* and opening now.
|
|
|
|
*/
|
|
|
|
reclaim_consumed_buffers(port);
|
|
|
|
spin_unlock_irq(&port->outvq_lock);
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
/* Notify host of port being opened */
|
|
|
|
send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
|
|
|
|
|
|
|
|
return 0;
|
2010-09-02 12:41:48 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
2009-12-21 16:19:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The file operations that we support: programs in the guest can open
|
|
|
|
* a console device, read from it, write to it, poll for data and
|
|
|
|
* close it. The devices are at
|
|
|
|
* /dev/vport<device number>p<port number>
|
|
|
|
*/
|
|
|
|
static const struct file_operations port_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = port_fops_open,
|
|
|
|
.read = port_fops_read,
|
|
|
|
.write = port_fops_write,
|
|
|
|
.poll = port_fops_poll,
|
|
|
|
.release = port_fops_release,
|
|
|
|
};
|
|
|
|
|
2010-01-18 13:44:55 +00:00
|
|
|
/*
|
|
|
|
* The put_chars() callback is pretty straightforward.
|
2007-10-22 01:03:39 +00:00
|
|
|
*
|
2010-01-18 13:44:55 +00:00
|
|
|
* We turn the characters into a scatter-gather list, add it to the
|
|
|
|
* output queue and then kick the Host. Then we sit here waiting for
|
|
|
|
* it to finish: inefficient in theory, but in practice
|
|
|
|
* implementations will do it immediately (lguest's Launcher does).
|
|
|
|
*/
|
2007-10-22 01:03:39 +00:00
|
|
|
static int put_chars(u32 vtermno, const char *buf, int count)
|
|
|
|
{
|
2010-01-18 13:45:00 +00:00
|
|
|
struct port *port;
|
2010-01-18 13:45:05 +00:00
|
|
|
|
2010-03-23 12:53:15 +00:00
|
|
|
if (unlikely(early_put_chars))
|
|
|
|
return early_put_chars(vtermno, buf, count);
|
|
|
|
|
2010-01-18 13:45:05 +00:00
|
|
|
port = find_port_by_vtermno(vtermno);
|
|
|
|
if (!port)
|
2010-05-20 04:15:47 +00:00
|
|
|
return -EPIPE;
|
2007-10-22 01:03:39 +00:00
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
return send_buf(port, (void *)buf, count, false);
|
2007-10-22 01:03:39 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 13:44:55 +00:00
|
|
|
/*
|
|
|
|
* get_chars() is the callback from the hvc_console infrastructure
|
|
|
|
* when an interrupt is received.
|
2007-10-22 01:03:39 +00:00
|
|
|
*
|
2010-01-18 13:45:12 +00:00
|
|
|
* We call out to fill_readbuf that gets us the required data from the
|
|
|
|
* buffers that are queued up.
|
2010-01-18 13:44:55 +00:00
|
|
|
*/
|
2007-10-22 01:03:39 +00:00
|
|
|
static int get_chars(u32 vtermno, char *buf, int count)
|
|
|
|
{
|
2010-01-18 13:45:00 +00:00
|
|
|
struct port *port;
|
|
|
|
|
2010-05-20 04:15:47 +00:00
|
|
|
/* If we've not set up the port yet, we have no input to give. */
|
|
|
|
if (unlikely(early_put_chars))
|
|
|
|
return 0;
|
|
|
|
|
2010-01-18 13:45:05 +00:00
|
|
|
port = find_port_by_vtermno(vtermno);
|
|
|
|
if (!port)
|
2010-05-20 04:15:47 +00:00
|
|
|
return -EPIPE;
|
2010-01-18 13:45:00 +00:00
|
|
|
|
2007-10-22 01:03:39 +00:00
|
|
|
/* If we don't have an input queue yet, we can't get input. */
|
2010-01-18 13:45:00 +00:00
|
|
|
BUG_ON(!port->in_vq);
|
2007-10-22 01:03:39 +00:00
|
|
|
|
2009-12-21 15:56:45 +00:00
|
|
|
return fill_readbuf(port, buf, count, false);
|
2007-10-22 01:03:39 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:08 +00:00
|
|
|
static void resize_console(struct port *port)
|
2008-11-25 12:36:26 +00:00
|
|
|
{
|
2010-01-18 13:45:08 +00:00
|
|
|
struct virtio_device *vdev;
|
2008-11-25 12:36:26 +00:00
|
|
|
|
2010-03-19 12:06:44 +00:00
|
|
|
/* The port could have been hot-unplugged */
|
2010-05-05 20:35:08 +00:00
|
|
|
if (!port || !is_console_port(port))
|
2010-03-19 12:06:44 +00:00
|
|
|
return;
|
|
|
|
|
2010-01-18 13:45:08 +00:00
|
|
|
vdev = port->portdev->vdev;
|
2010-05-05 20:35:08 +00:00
|
|
|
if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE))
|
|
|
|
hvc_resize(port->cons.hvc, port->cons.ws);
|
2008-11-25 12:36:26 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:05 +00:00
|
|
|
/* We set the configuration at this point, since we now have a tty */
|
2008-06-20 13:24:15 +00:00
|
|
|
static int notifier_add_vio(struct hvc_struct *hp, int data)
|
|
|
|
{
|
2010-01-18 13:45:05 +00:00
|
|
|
struct port *port;
|
|
|
|
|
|
|
|
port = find_port_by_vtermno(hp->vtermno);
|
|
|
|
if (!port)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-06-20 13:24:15 +00:00
|
|
|
hp->irq_requested = 1;
|
2010-01-18 13:45:08 +00:00
|
|
|
resize_console(port);
|
2008-11-25 12:36:26 +00:00
|
|
|
|
2008-06-20 13:24:15 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void notifier_del_vio(struct hvc_struct *hp, int data)
|
|
|
|
{
|
|
|
|
hp->irq_requested = 0;
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
/* The operations for console ports. */
|
2009-11-28 06:50:26 +00:00
|
|
|
static const struct hv_ops hv_ops = {
|
2010-01-18 13:44:56 +00:00
|
|
|
.get_chars = get_chars,
|
|
|
|
.put_chars = put_chars,
|
|
|
|
.notifier_add = notifier_add_vio,
|
|
|
|
.notifier_del = notifier_del_vio,
|
|
|
|
.notifier_hangup = notifier_del_vio,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Console drivers are initialized very early so boot messages can go
|
|
|
|
* out, so we do things slightly differently from the generic virtio
|
|
|
|
* initialization of the net and block drivers.
|
|
|
|
*
|
|
|
|
* At this stage, the console is output-only. It's too early to set
|
|
|
|
* up a virtqueue, so we let the drivers do some boutique early-output
|
|
|
|
* thing.
|
|
|
|
*/
|
|
|
|
int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
|
|
|
|
{
|
|
|
|
early_put_chars = put_chars;
|
|
|
|
return hvc_instantiate(0, 0, &hv_ops);
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
int init_port_console(struct port *port)
|
2010-01-18 13:45:10 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The Host's telling us this port is a console port. Hook it
|
|
|
|
* up with an hvc console.
|
|
|
|
*
|
|
|
|
* To set up and manage our virtual console, we call
|
|
|
|
* hvc_alloc().
|
|
|
|
*
|
|
|
|
* The first argument of hvc_alloc() is the virtual console
|
|
|
|
* number. The second argument is the parameter for the
|
|
|
|
* notification mechanism (like irq number). We currently
|
|
|
|
* leave this as zero, virtqueues have implicit notifications.
|
|
|
|
*
|
|
|
|
* The third argument is a "struct hv_ops" containing the
|
|
|
|
* put_chars() get_chars(), notifier_add() and notifier_del()
|
|
|
|
* pointers. The final argument is the output buffer size: we
|
|
|
|
* can do any size, so we put PAGE_SIZE here.
|
|
|
|
*/
|
|
|
|
port->cons.vtermno = pdrvdata.next_vtermno;
|
|
|
|
|
|
|
|
port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
|
|
|
|
if (IS_ERR(port->cons.hvc)) {
|
|
|
|
ret = PTR_ERR(port->cons.hvc);
|
2010-01-18 11:05:23 +00:00
|
|
|
dev_err(port->dev,
|
|
|
|
"error %d allocating hvc for port\n", ret);
|
2010-01-18 13:45:10 +00:00
|
|
|
port->cons.hvc = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
spin_lock_irq(&pdrvdata_lock);
|
|
|
|
pdrvdata.next_vtermno++;
|
|
|
|
list_add_tail(&port->cons.list, &pdrvdata.consoles);
|
|
|
|
spin_unlock_irq(&pdrvdata_lock);
|
2009-11-26 05:55:38 +00:00
|
|
|
port->guest_connected = true;
|
2010-01-18 13:45:10 +00:00
|
|
|
|
2010-05-20 04:15:49 +00:00
|
|
|
/*
|
|
|
|
* Start using the new console output if this is the first
|
|
|
|
* console to come up.
|
|
|
|
*/
|
|
|
|
if (early_put_chars)
|
|
|
|
early_put_chars = NULL;
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
/* Notify host of port being opened */
|
|
|
|
send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
|
|
|
|
|
2010-01-18 13:45:10 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:27:40 +00:00
|
|
|
static ssize_t show_port_name(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buffer)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
|
|
|
|
port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
return sprintf(buffer, "%s\n", port->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
|
|
|
|
|
|
|
|
static struct attribute *port_sysfs_entries[] = {
|
|
|
|
&dev_attr_name.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group port_attribute_group = {
|
|
|
|
.name = NULL, /* put in device directory */
|
|
|
|
.attrs = port_sysfs_entries,
|
|
|
|
};
|
|
|
|
|
2009-12-21 17:06:21 +00:00
|
|
|
static int debugfs_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
filp->private_data = inode->i_private;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
|
|
|
|
size_t count, loff_t *offp)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
char *buf;
|
|
|
|
ssize_t ret, out_offset, out_count;
|
|
|
|
|
|
|
|
out_count = 1024;
|
|
|
|
buf = kmalloc(out_count, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
port = filp->private_data;
|
|
|
|
out_offset = 0;
|
|
|
|
out_offset += snprintf(buf + out_offset, out_count,
|
|
|
|
"name: %s\n", port->name ? port->name : "");
|
|
|
|
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
|
|
|
"guest_connected: %d\n", port->guest_connected);
|
|
|
|
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
|
|
|
"host_connected: %d\n", port->host_connected);
|
2010-05-20 04:15:50 +00:00
|
|
|
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
|
|
|
"outvq_full: %d\n", port->outvq_full);
|
2009-12-21 17:06:21 +00:00
|
|
|
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
|
|
|
"is_console: %s\n",
|
|
|
|
is_console_port(port) ? "yes" : "no");
|
|
|
|
out_offset += snprintf(buf + out_offset, out_count - out_offset,
|
|
|
|
"console_vtermno: %u\n", port->cons.vtermno);
|
|
|
|
|
|
|
|
ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
|
|
|
|
kfree(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations port_debugfs_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = debugfs_open,
|
|
|
|
.read = debugfs_read,
|
|
|
|
};
|
|
|
|
|
2010-05-05 20:35:08 +00:00
|
|
|
static void set_console_size(struct port *port, u16 rows, u16 cols)
|
|
|
|
{
|
|
|
|
if (!port || !is_console_port(port))
|
|
|
|
return;
|
|
|
|
|
|
|
|
port->cons.ws.ws_row = rows;
|
|
|
|
port->cons.ws.ws_col = cols;
|
|
|
|
}
|
|
|
|
|
2010-05-20 04:15:48 +00:00
|
|
|
static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
|
|
|
|
{
|
|
|
|
struct port_buffer *buf;
|
|
|
|
unsigned int nr_added_bufs;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
nr_added_bufs = 0;
|
|
|
|
do {
|
|
|
|
buf = alloc_buf(PAGE_SIZE);
|
|
|
|
if (!buf)
|
|
|
|
break;
|
|
|
|
|
|
|
|
spin_lock_irq(lock);
|
|
|
|
ret = add_inbuf(vq, buf);
|
|
|
|
if (ret < 0) {
|
|
|
|
spin_unlock_irq(lock);
|
|
|
|
free_buf(buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
nr_added_bufs++;
|
|
|
|
spin_unlock_irq(lock);
|
|
|
|
} while (ret > 0);
|
|
|
|
|
|
|
|
return nr_added_bufs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int add_port(struct ports_device *portdev, u32 id)
|
|
|
|
{
|
|
|
|
char debugfs_name[16];
|
|
|
|
struct port *port;
|
|
|
|
struct port_buffer *buf;
|
|
|
|
dev_t devt;
|
|
|
|
unsigned int nr_added_bufs;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
port = kmalloc(sizeof(*port), GFP_KERNEL);
|
|
|
|
if (!port) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
port->portdev = portdev;
|
|
|
|
port->id = id;
|
|
|
|
|
|
|
|
port->name = NULL;
|
|
|
|
port->inbuf = NULL;
|
|
|
|
port->cons.hvc = NULL;
|
|
|
|
|
2010-05-05 20:35:08 +00:00
|
|
|
port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
|
|
|
|
|
2010-05-20 04:15:48 +00:00
|
|
|
port->host_connected = port->guest_connected = false;
|
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
port->outvq_full = false;
|
|
|
|
|
2010-05-20 04:15:48 +00:00
|
|
|
port->in_vq = portdev->in_vqs[port->id];
|
|
|
|
port->out_vq = portdev->out_vqs[port->id];
|
|
|
|
|
|
|
|
cdev_init(&port->cdev, &port_fops);
|
|
|
|
|
|
|
|
devt = MKDEV(portdev->chr_major, id);
|
|
|
|
err = cdev_add(&port->cdev, devt, 1);
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(&port->portdev->vdev->dev,
|
|
|
|
"Error %d adding cdev for port %u\n", err, id);
|
|
|
|
goto free_port;
|
|
|
|
}
|
|
|
|
port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
|
|
|
|
devt, port, "vport%up%u",
|
|
|
|
port->portdev->drv_index, id);
|
|
|
|
if (IS_ERR(port->dev)) {
|
|
|
|
err = PTR_ERR(port->dev);
|
|
|
|
dev_err(&port->portdev->vdev->dev,
|
|
|
|
"Error %d creating device for port %u\n",
|
|
|
|
err, id);
|
|
|
|
goto free_cdev;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_init(&port->inbuf_lock);
|
2010-05-20 04:15:50 +00:00
|
|
|
spin_lock_init(&port->outvq_lock);
|
2010-05-20 04:15:48 +00:00
|
|
|
init_waitqueue_head(&port->waitqueue);
|
|
|
|
|
|
|
|
/* Fill the in_vq with buffers so the host can send us data. */
|
|
|
|
nr_added_bufs = fill_queue(port->in_vq, &port->inbuf_lock);
|
|
|
|
if (!nr_added_bufs) {
|
|
|
|
dev_err(port->dev, "Error allocating inbufs\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_device;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're not using multiport support, this has to be a console port
|
|
|
|
*/
|
|
|
|
if (!use_multiport(port->portdev)) {
|
|
|
|
err = init_port_console(port);
|
|
|
|
if (err)
|
|
|
|
goto free_inbufs;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irq(&portdev->ports_lock);
|
|
|
|
list_add_tail(&port->list, &port->portdev->ports);
|
|
|
|
spin_unlock_irq(&portdev->ports_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell the Host we're set so that it can send us various
|
|
|
|
* configuration parameters for this port (eg, port name,
|
|
|
|
* caching, whether this is a console port, etc.)
|
|
|
|
*/
|
|
|
|
send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
|
|
|
|
|
|
|
|
if (pdrvdata.debugfs_dir) {
|
|
|
|
/*
|
|
|
|
* Finally, create the debugfs file that we can use to
|
|
|
|
* inspect a port's state at any time
|
|
|
|
*/
|
|
|
|
sprintf(debugfs_name, "vport%up%u",
|
|
|
|
port->portdev->drv_index, id);
|
|
|
|
port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
|
|
|
|
pdrvdata.debugfs_dir,
|
|
|
|
port,
|
|
|
|
&port_debugfs_ops);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
free_inbufs:
|
|
|
|
while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
|
|
|
|
free_buf(buf);
|
|
|
|
free_device:
|
|
|
|
device_destroy(pdrvdata.class, port->dev->devt);
|
|
|
|
free_cdev:
|
|
|
|
cdev_del(&port->cdev);
|
|
|
|
free_port:
|
|
|
|
kfree(port);
|
|
|
|
fail:
|
|
|
|
/* The host might want to notify management sw about port add failure */
|
drivers/char: Eliminate use after free
In each case, the first argument to send_control_msg or __send_control_msg,
respectively, has either not been successfully allocated or has been freed
at the point of the call. In the first case, the first argument, port, is
only used to access the portdev and id fields, in order to call
__send_control_msg. Thus it seems possible instead to call
__send_control_msg directly. In the second case, the call to
__send_control_msg is moved up to a place where it seems like the first
argument, portdev, has been initialized sufficiently to make the call to
__send_control_msg meaningful.
This has only been compile tested.
A simplified version of the semantic match that finds this problem is as
follows: (http://coccinelle.lip6.fr/)
// <smpl>
@free@
expression E;
position p;
@@
kfree@p(E)
@@
expression free.E, subE<=free.E, E1;
position free.p;
@@
kfree@p(E)
...
(
subE = E1
|
* E
)
// </smpl>
Signed-off-by: Julia Lawall <julia@diku.dk>
Acked-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2010-05-15 09:45:53 +00:00
|
|
|
__send_control_msg(portdev, id, VIRTIO_CONSOLE_PORT_READY, 0);
|
2010-05-20 04:15:48 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:57:31 +00:00
|
|
|
/* Remove all port-specific data. */
|
2010-09-02 12:41:47 +00:00
|
|
|
static void remove_port(struct port *port)
|
2009-12-21 16:57:31 +00:00
|
|
|
{
|
2010-02-12 05:02:15 +00:00
|
|
|
struct port_buffer *buf;
|
|
|
|
|
2010-05-27 07:54:39 +00:00
|
|
|
if (port->guest_connected) {
|
|
|
|
port->guest_connected = false;
|
|
|
|
port->host_connected = false;
|
|
|
|
wake_up_interruptible(&port->waitqueue);
|
|
|
|
send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:57:31 +00:00
|
|
|
spin_lock_irq(&port->portdev->ports_lock);
|
|
|
|
list_del(&port->list);
|
|
|
|
spin_unlock_irq(&port->portdev->ports_lock);
|
|
|
|
|
|
|
|
if (is_console_port(port)) {
|
|
|
|
spin_lock_irq(&pdrvdata_lock);
|
|
|
|
list_del(&port->cons.list);
|
|
|
|
spin_unlock_irq(&pdrvdata_lock);
|
2010-05-20 04:15:47 +00:00
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
* hvc_remove() not called as removing one hvc port
|
|
|
|
* results in other hvc ports getting frozen.
|
|
|
|
*
|
|
|
|
* Once this is resolved in hvc, this functionality
|
|
|
|
* will be enabled. Till that is done, the -EPIPE
|
|
|
|
* return from get_chars() above will help
|
|
|
|
* hvc_console.c to clean up on ports we remove here.
|
|
|
|
*/
|
2009-12-21 16:57:31 +00:00
|
|
|
hvc_remove(port->cons.hvc);
|
2010-05-20 04:15:47 +00:00
|
|
|
#endif
|
2009-12-21 16:57:31 +00:00
|
|
|
}
|
|
|
|
sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
|
|
|
|
device_destroy(pdrvdata.class, port->dev->devt);
|
|
|
|
cdev_del(&port->cdev);
|
|
|
|
|
2010-02-12 05:02:15 +00:00
|
|
|
/* Remove unused data this port might have received. */
|
2009-12-21 16:57:31 +00:00
|
|
|
discard_port_data(port);
|
2010-02-12 05:02:15 +00:00
|
|
|
|
2010-05-20 04:15:50 +00:00
|
|
|
reclaim_consumed_buffers(port);
|
|
|
|
|
2010-02-12 05:02:15 +00:00
|
|
|
/* Remove buffers we queued up for the Host to send us data in. */
|
2010-04-12 13:18:32 +00:00
|
|
|
while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
|
2010-02-12 05:02:15 +00:00
|
|
|
free_buf(buf);
|
|
|
|
|
2009-12-21 16:57:31 +00:00
|
|
|
kfree(port->name);
|
|
|
|
|
2009-12-21 17:06:21 +00:00
|
|
|
debugfs_remove(port->debugfs_file);
|
|
|
|
|
2009-12-21 16:57:31 +00:00
|
|
|
kfree(port);
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
/* Any private messages that the Host and Guest want to share */
|
|
|
|
static void handle_control_message(struct ports_device *portdev,
|
|
|
|
struct port_buffer *buf)
|
|
|
|
{
|
|
|
|
struct virtio_console_control *cpkt;
|
|
|
|
struct port *port;
|
2009-12-21 16:27:40 +00:00
|
|
|
size_t name_size;
|
|
|
|
int err;
|
2009-12-21 15:33:25 +00:00
|
|
|
|
|
|
|
cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
|
|
|
|
|
|
|
|
port = find_port_by_id(portdev, cpkt->id);
|
2010-05-20 04:15:48 +00:00
|
|
|
if (!port && cpkt->event != VIRTIO_CONSOLE_PORT_ADD) {
|
2009-12-21 15:33:25 +00:00
|
|
|
/* No valid header at start of buffer. Drop it. */
|
|
|
|
dev_dbg(&portdev->vdev->dev,
|
|
|
|
"Invalid index %u in control packet\n", cpkt->id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (cpkt->event) {
|
2010-05-20 04:15:48 +00:00
|
|
|
case VIRTIO_CONSOLE_PORT_ADD:
|
|
|
|
if (port) {
|
2010-05-20 04:15:49 +00:00
|
|
|
dev_dbg(&portdev->vdev->dev,
|
|
|
|
"Port %u already added\n", port->id);
|
2010-05-20 04:15:48 +00:00
|
|
|
send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cpkt->id >= portdev->config.max_nr_ports) {
|
|
|
|
dev_warn(&portdev->vdev->dev,
|
|
|
|
"Request for adding port with out-of-bound id %u, max. supported id: %u\n",
|
|
|
|
cpkt->id, portdev->config.max_nr_ports - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
add_port(portdev, cpkt->id);
|
|
|
|
break;
|
|
|
|
case VIRTIO_CONSOLE_PORT_REMOVE:
|
|
|
|
remove_port(port);
|
|
|
|
break;
|
2009-12-21 15:33:25 +00:00
|
|
|
case VIRTIO_CONSOLE_CONSOLE_PORT:
|
|
|
|
if (!cpkt->value)
|
|
|
|
break;
|
|
|
|
if (is_console_port(port))
|
|
|
|
break;
|
|
|
|
|
|
|
|
init_port_console(port);
|
|
|
|
/*
|
|
|
|
* Could remove the port here in case init fails - but
|
|
|
|
* have to notify the host first.
|
|
|
|
*/
|
|
|
|
break;
|
2010-05-05 20:35:09 +00:00
|
|
|
case VIRTIO_CONSOLE_RESIZE: {
|
|
|
|
struct {
|
|
|
|
__u16 rows;
|
|
|
|
__u16 cols;
|
|
|
|
} size;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
if (!is_console_port(port))
|
|
|
|
break;
|
2010-05-05 20:35:09 +00:00
|
|
|
|
|
|
|
memcpy(&size, buf->buf + buf->offset + sizeof(*cpkt),
|
|
|
|
sizeof(size));
|
|
|
|
set_console_size(port, size.rows, size.cols);
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
port->cons.hvc->irq_requested = 1;
|
|
|
|
resize_console(port);
|
|
|
|
break;
|
2010-05-05 20:35:09 +00:00
|
|
|
}
|
2009-12-21 16:19:30 +00:00
|
|
|
case VIRTIO_CONSOLE_PORT_OPEN:
|
|
|
|
port->host_connected = cpkt->value;
|
|
|
|
wake_up_interruptible(&port->waitqueue);
|
2010-05-20 04:15:50 +00:00
|
|
|
/*
|
|
|
|
* If the host port got closed and the host had any
|
|
|
|
* unconsumed buffers, we'll be able to reclaim them
|
|
|
|
* now.
|
|
|
|
*/
|
|
|
|
spin_lock_irq(&port->outvq_lock);
|
|
|
|
reclaim_consumed_buffers(port);
|
|
|
|
spin_unlock_irq(&port->outvq_lock);
|
2009-12-21 16:19:30 +00:00
|
|
|
break;
|
2009-12-21 16:27:40 +00:00
|
|
|
case VIRTIO_CONSOLE_PORT_NAME:
|
|
|
|
/*
|
|
|
|
* Skip the size of the header and the cpkt to get the size
|
|
|
|
* of the name that was sent
|
|
|
|
*/
|
|
|
|
name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
|
|
|
|
|
|
|
|
port->name = kmalloc(name_size, GFP_KERNEL);
|
|
|
|
if (!port->name) {
|
|
|
|
dev_err(port->dev,
|
|
|
|
"Not enough space to store port name\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
|
|
|
|
name_size - 1);
|
|
|
|
port->name[name_size - 1] = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we only have one sysfs attribute, 'name',
|
|
|
|
* create it only if we have a name for the port.
|
|
|
|
*/
|
|
|
|
err = sysfs_create_group(&port->dev->kobj,
|
|
|
|
&port_attribute_group);
|
2010-03-19 12:06:43 +00:00
|
|
|
if (err) {
|
2009-12-21 16:27:40 +00:00
|
|
|
dev_err(port->dev,
|
|
|
|
"Error %d creating sysfs device attributes\n",
|
|
|
|
err);
|
2010-03-19 12:06:43 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Generate a udev event so that appropriate
|
|
|
|
* symlinks can be created based on udev
|
|
|
|
* rules.
|
|
|
|
*/
|
|
|
|
kobject_uevent(&port->dev->kobj, KOBJ_CHANGE);
|
|
|
|
}
|
2009-12-21 16:27:40 +00:00
|
|
|
break;
|
2009-12-21 15:33:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void control_work_handler(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct ports_device *portdev;
|
|
|
|
struct virtqueue *vq;
|
|
|
|
struct port_buffer *buf;
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
portdev = container_of(work, struct ports_device, control_work);
|
|
|
|
vq = portdev->c_ivq;
|
|
|
|
|
|
|
|
spin_lock(&portdev->cvq_lock);
|
2010-04-12 13:18:32 +00:00
|
|
|
while ((buf = virtqueue_get_buf(vq, &len))) {
|
2009-12-21 15:33:25 +00:00
|
|
|
spin_unlock(&portdev->cvq_lock);
|
|
|
|
|
|
|
|
buf->len = len;
|
|
|
|
buf->offset = 0;
|
|
|
|
|
|
|
|
handle_control_message(portdev, buf);
|
|
|
|
|
|
|
|
spin_lock(&portdev->cvq_lock);
|
|
|
|
if (add_inbuf(portdev->c_ivq, buf) < 0) {
|
|
|
|
dev_warn(&portdev->vdev->dev,
|
|
|
|
"Error adding buffer to queue\n");
|
|
|
|
free_buf(buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&portdev->cvq_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void in_intr(struct virtqueue *vq)
|
|
|
|
{
|
|
|
|
struct port *port;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
port = find_port_by_vq(vq->vdev->priv, vq);
|
|
|
|
if (!port)
|
|
|
|
return;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->inbuf_lock, flags);
|
2010-02-12 05:02:18 +00:00
|
|
|
if (!port->inbuf)
|
|
|
|
port->inbuf = get_inbuf(port);
|
2009-12-21 15:33:25 +00:00
|
|
|
|
2009-12-21 16:45:30 +00:00
|
|
|
/*
|
|
|
|
* Don't queue up data when port is closed. This condition
|
|
|
|
* can be reached when a console port is not yet connected (no
|
|
|
|
* tty is spawned) and the host sends out data to console
|
|
|
|
* ports. For generic serial ports, the host won't
|
|
|
|
* (shouldn't) send data till the guest is connected.
|
|
|
|
*/
|
|
|
|
if (!port->guest_connected)
|
|
|
|
discard_port_data(port);
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
spin_unlock_irqrestore(&port->inbuf_lock, flags);
|
|
|
|
|
2009-12-21 16:19:30 +00:00
|
|
|
wake_up_interruptible(&port->waitqueue);
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
if (is_console_port(port) && hvc_poll(port->cons.hvc))
|
|
|
|
hvc_kick();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void control_intr(struct virtqueue *vq)
|
|
|
|
{
|
|
|
|
struct ports_device *portdev;
|
|
|
|
|
|
|
|
portdev = vq->vdev->priv;
|
|
|
|
schedule_work(&portdev->control_work);
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:52:08 +00:00
|
|
|
static void config_intr(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
struct ports_device *portdev;
|
|
|
|
|
|
|
|
portdev = vdev->priv;
|
2010-05-20 04:15:48 +00:00
|
|
|
|
2010-05-05 20:35:07 +00:00
|
|
|
if (!use_multiport(portdev)) {
|
2010-05-05 20:35:08 +00:00
|
|
|
struct port *port;
|
|
|
|
u16 rows, cols;
|
|
|
|
|
|
|
|
vdev->config->get(vdev,
|
|
|
|
offsetof(struct virtio_console_config, cols),
|
|
|
|
&cols, sizeof(u16));
|
|
|
|
vdev->config->get(vdev,
|
|
|
|
offsetof(struct virtio_console_config, rows),
|
|
|
|
&rows, sizeof(u16));
|
|
|
|
|
|
|
|
port = find_port_by_id(portdev, 0);
|
|
|
|
set_console_size(port, rows, cols);
|
|
|
|
|
2010-05-05 20:35:07 +00:00
|
|
|
/*
|
|
|
|
* We'll use this way of resizing only for legacy
|
|
|
|
* support. For newer userspace
|
|
|
|
* (VIRTIO_CONSOLE_F_MULTPORT+), use control messages
|
|
|
|
* to indicate console size changes so that it can be
|
|
|
|
* done per-port.
|
|
|
|
*/
|
2010-05-05 20:35:08 +00:00
|
|
|
resize_console(port);
|
2010-05-05 20:35:07 +00:00
|
|
|
}
|
2009-12-21 16:52:08 +00:00
|
|
|
}
|
|
|
|
|
2010-01-18 13:45:11 +00:00
|
|
|
static int init_vqs(struct ports_device *portdev)
|
|
|
|
{
|
|
|
|
vq_callback_t **io_callbacks;
|
|
|
|
char **io_names;
|
|
|
|
struct virtqueue **vqs;
|
2009-12-21 15:33:25 +00:00
|
|
|
u32 i, j, nr_ports, nr_queues;
|
2010-01-18 13:45:11 +00:00
|
|
|
int err;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
nr_ports = portdev->config.max_nr_ports;
|
|
|
|
nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
|
2010-01-18 13:45:11 +00:00
|
|
|
|
|
|
|
vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
|
|
|
|
if (!vqs) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
|
|
|
|
if (!io_callbacks) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_vqs;
|
|
|
|
}
|
|
|
|
io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
|
|
|
|
if (!io_names) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_callbacks;
|
|
|
|
}
|
|
|
|
portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!portdev->in_vqs) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_names;
|
|
|
|
}
|
|
|
|
portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!portdev->out_vqs) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_invqs;
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
/*
|
|
|
|
* For backward compat (newer host but older guest), the host
|
|
|
|
* spawns a console port first and also inits the vqs for port
|
|
|
|
* 0 before others.
|
|
|
|
*/
|
|
|
|
j = 0;
|
|
|
|
io_callbacks[j] = in_intr;
|
|
|
|
io_callbacks[j + 1] = NULL;
|
|
|
|
io_names[j] = "input";
|
|
|
|
io_names[j + 1] = "output";
|
|
|
|
j += 2;
|
|
|
|
|
|
|
|
if (use_multiport(portdev)) {
|
|
|
|
io_callbacks[j] = control_intr;
|
|
|
|
io_callbacks[j + 1] = NULL;
|
|
|
|
io_names[j] = "control-i";
|
|
|
|
io_names[j + 1] = "control-o";
|
|
|
|
|
|
|
|
for (i = 1; i < nr_ports; i++) {
|
|
|
|
j += 2;
|
|
|
|
io_callbacks[j] = in_intr;
|
|
|
|
io_callbacks[j + 1] = NULL;
|
|
|
|
io_names[j] = "input";
|
|
|
|
io_names[j + 1] = "output";
|
|
|
|
}
|
|
|
|
}
|
2010-01-18 13:45:11 +00:00
|
|
|
/* Find the queues. */
|
|
|
|
err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
|
|
|
|
io_callbacks,
|
|
|
|
(const char **)io_names);
|
|
|
|
if (err)
|
|
|
|
goto free_outvqs;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
j = 0;
|
2010-01-18 13:45:11 +00:00
|
|
|
portdev->in_vqs[0] = vqs[0];
|
|
|
|
portdev->out_vqs[0] = vqs[1];
|
2009-12-21 15:33:25 +00:00
|
|
|
j += 2;
|
|
|
|
if (use_multiport(portdev)) {
|
|
|
|
portdev->c_ivq = vqs[j];
|
|
|
|
portdev->c_ovq = vqs[j + 1];
|
|
|
|
|
|
|
|
for (i = 1; i < nr_ports; i++) {
|
|
|
|
j += 2;
|
|
|
|
portdev->in_vqs[i] = vqs[j];
|
|
|
|
portdev->out_vqs[i] = vqs[j + 1];
|
|
|
|
}
|
|
|
|
}
|
2010-01-18 13:45:11 +00:00
|
|
|
kfree(io_callbacks);
|
|
|
|
kfree(io_names);
|
|
|
|
kfree(vqs);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
free_names:
|
|
|
|
kfree(io_names);
|
|
|
|
free_callbacks:
|
|
|
|
kfree(io_callbacks);
|
|
|
|
free_outvqs:
|
|
|
|
kfree(portdev->out_vqs);
|
|
|
|
free_invqs:
|
|
|
|
kfree(portdev->in_vqs);
|
|
|
|
free_vqs:
|
|
|
|
kfree(vqs);
|
|
|
|
fail:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-12-21 16:06:04 +00:00
|
|
|
static const struct file_operations portdev_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2010-01-18 13:45:07 +00:00
|
|
|
/*
|
|
|
|
* Once we're further in boot, we get probed like any other virtio
|
|
|
|
* device.
|
2009-12-21 15:33:25 +00:00
|
|
|
*
|
|
|
|
* If the host also supports multiple console ports, we check the
|
|
|
|
* config space to see how many ports the host has spawned. We
|
|
|
|
* initialize each port found.
|
2010-01-18 13:45:07 +00:00
|
|
|
*/
|
|
|
|
static int __devinit virtcons_probe(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
struct ports_device *portdev;
|
|
|
|
int err;
|
2009-12-21 15:33:25 +00:00
|
|
|
bool multiport;
|
2010-01-18 13:45:07 +00:00
|
|
|
|
|
|
|
portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
|
|
|
|
if (!portdev) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Attach this portdev to this virtio_device, and vice-versa. */
|
|
|
|
portdev->vdev = vdev;
|
|
|
|
vdev->priv = portdev;
|
|
|
|
|
2009-12-21 16:06:04 +00:00
|
|
|
spin_lock_irq(&pdrvdata_lock);
|
|
|
|
portdev->drv_index = pdrvdata.index++;
|
|
|
|
spin_unlock_irq(&pdrvdata_lock);
|
|
|
|
|
|
|
|
portdev->chr_major = register_chrdev(0, "virtio-portsdev",
|
|
|
|
&portdev_fops);
|
|
|
|
if (portdev->chr_major < 0) {
|
|
|
|
dev_err(&vdev->dev,
|
|
|
|
"Error %d registering chrdev for device %u\n",
|
|
|
|
portdev->chr_major, portdev->drv_index);
|
|
|
|
err = portdev->chr_major;
|
|
|
|
goto free;
|
|
|
|
}
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
multiport = false;
|
|
|
|
portdev->config.max_nr_ports = 1;
|
|
|
|
if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) {
|
|
|
|
multiport = true;
|
|
|
|
vdev->features[0] |= 1 << VIRTIO_CONSOLE_F_MULTIPORT;
|
|
|
|
|
2010-05-20 04:15:46 +00:00
|
|
|
vdev->config->get(vdev, offsetof(struct virtio_console_config,
|
|
|
|
max_nr_ports),
|
2009-12-21 15:33:25 +00:00
|
|
|
&portdev->config.max_nr_ports,
|
|
|
|
sizeof(portdev->config.max_nr_ports));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Let the Host know we support multiple ports.*/
|
|
|
|
vdev->config->finalize_features(vdev);
|
|
|
|
|
2010-01-18 13:45:11 +00:00
|
|
|
err = init_vqs(portdev);
|
|
|
|
if (err < 0) {
|
|
|
|
dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
|
2009-12-21 16:06:04 +00:00
|
|
|
goto free_chrdev;
|
2010-01-18 13:45:11 +00:00
|
|
|
}
|
2010-01-18 13:45:07 +00:00
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
spin_lock_init(&portdev->ports_lock);
|
|
|
|
INIT_LIST_HEAD(&portdev->ports);
|
|
|
|
|
|
|
|
if (multiport) {
|
2010-02-24 05:07:44 +00:00
|
|
|
unsigned int nr_added_bufs;
|
|
|
|
|
2009-12-21 15:33:25 +00:00
|
|
|
spin_lock_init(&portdev->cvq_lock);
|
|
|
|
INIT_WORK(&portdev->control_work, &control_work_handler);
|
|
|
|
|
2010-02-24 05:07:44 +00:00
|
|
|
nr_added_bufs = fill_queue(portdev->c_ivq, &portdev->cvq_lock);
|
|
|
|
if (!nr_added_bufs) {
|
2010-02-12 05:02:17 +00:00
|
|
|
dev_err(&vdev->dev,
|
|
|
|
"Error allocating buffers for control queue\n");
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto free_vqs;
|
|
|
|
}
|
2010-05-20 04:15:49 +00:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* For backward compatibility: Create a console port
|
|
|
|
* if we're running on older host.
|
|
|
|
*/
|
|
|
|
add_port(portdev, 0);
|
2009-12-21 15:33:25 +00:00
|
|
|
}
|
|
|
|
|
2010-09-02 12:41:49 +00:00
|
|
|
spin_lock_irq(&pdrvdata_lock);
|
|
|
|
list_add_tail(&portdev->list, &pdrvdata.portdevs);
|
|
|
|
spin_unlock_irq(&pdrvdata_lock);
|
|
|
|
|
2010-05-20 04:15:48 +00:00
|
|
|
__send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
|
|
|
|
VIRTIO_CONSOLE_DEVICE_READY, 1);
|
2007-10-22 01:03:39 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-02-12 05:02:17 +00:00
|
|
|
free_vqs:
|
drivers/char: Eliminate use after free
In each case, the first argument to send_control_msg or __send_control_msg,
respectively, has either not been successfully allocated or has been freed
at the point of the call. In the first case, the first argument, port, is
only used to access the portdev and id fields, in order to call
__send_control_msg. Thus it seems possible instead to call
__send_control_msg directly. In the second case, the call to
__send_control_msg is moved up to a place where it seems like the first
argument, portdev, has been initialized sufficiently to make the call to
__send_control_msg meaningful.
This has only been compile tested.
A simplified version of the semantic match that finds this problem is as
follows: (http://coccinelle.lip6.fr/)
// <smpl>
@free@
expression E;
position p;
@@
kfree@p(E)
@@
expression free.E, subE<=free.E, E1;
position free.p;
@@
kfree@p(E)
...
(
subE = E1
|
* E
)
// </smpl>
Signed-off-by: Julia Lawall <julia@diku.dk>
Acked-by: Amit Shah <amit.shah@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2010-05-15 09:45:53 +00:00
|
|
|
/* The host might want to notify mgmt sw about device add failure */
|
|
|
|
__send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
|
|
|
|
VIRTIO_CONSOLE_DEVICE_READY, 0);
|
2010-02-12 05:02:17 +00:00
|
|
|
vdev->config->del_vqs(vdev);
|
|
|
|
kfree(portdev->in_vqs);
|
|
|
|
kfree(portdev->out_vqs);
|
2009-12-21 16:06:04 +00:00
|
|
|
free_chrdev:
|
|
|
|
unregister_chrdev(portdev->chr_major, "virtio-portsdev");
|
2007-10-22 01:03:39 +00:00
|
|
|
free:
|
2010-01-18 13:45:07 +00:00
|
|
|
kfree(portdev);
|
2007-10-22 01:03:39 +00:00
|
|
|
fail:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-02-12 05:02:16 +00:00
|
|
|
static void virtcons_remove(struct virtio_device *vdev)
|
|
|
|
{
|
|
|
|
struct ports_device *portdev;
|
|
|
|
struct port *port, *port2;
|
|
|
|
|
|
|
|
portdev = vdev->priv;
|
|
|
|
|
2010-09-02 12:41:49 +00:00
|
|
|
spin_lock_irq(&pdrvdata_lock);
|
|
|
|
list_del(&portdev->list);
|
|
|
|
spin_unlock_irq(&pdrvdata_lock);
|
|
|
|
|
2010-09-02 12:41:40 +00:00
|
|
|
/* Disable interrupts for vqs */
|
|
|
|
vdev->config->reset(vdev);
|
|
|
|
/* Finish up work that's lined up */
|
2010-02-12 05:02:16 +00:00
|
|
|
cancel_work_sync(&portdev->control_work);
|
|
|
|
|
|
|
|
list_for_each_entry_safe(port, port2, &portdev->ports, list)
|
|
|
|
remove_port(port);
|
|
|
|
|
|
|
|
unregister_chrdev(portdev->chr_major, "virtio-portsdev");
|
|
|
|
|
2010-09-02 12:41:41 +00:00
|
|
|
if (use_multiport(portdev)) {
|
|
|
|
struct port_buffer *buf;
|
|
|
|
unsigned int len;
|
2010-02-12 05:02:16 +00:00
|
|
|
|
2010-09-02 12:41:41 +00:00
|
|
|
while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
|
|
|
|
free_buf(buf);
|
|
|
|
|
|
|
|
while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
|
|
|
|
free_buf(buf);
|
|
|
|
}
|
2010-02-12 05:02:16 +00:00
|
|
|
|
|
|
|
vdev->config->del_vqs(vdev);
|
|
|
|
kfree(portdev->in_vqs);
|
|
|
|
kfree(portdev->out_vqs);
|
|
|
|
|
|
|
|
kfree(portdev);
|
|
|
|
}
|
|
|
|
|
2007-10-22 01:03:39 +00:00
|
|
|
static struct virtio_device_id id_table[] = {
|
|
|
|
{ VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
|
|
|
|
{ 0 },
|
|
|
|
};
|
|
|
|
|
2008-11-25 12:36:26 +00:00
|
|
|
static unsigned int features[] = {
|
|
|
|
VIRTIO_CONSOLE_F_SIZE,
|
2010-05-20 04:15:46 +00:00
|
|
|
VIRTIO_CONSOLE_F_MULTIPORT,
|
2008-11-25 12:36:26 +00:00
|
|
|
};
|
|
|
|
|
2007-10-22 01:03:39 +00:00
|
|
|
static struct virtio_driver virtio_console = {
|
2008-11-25 12:36:26 +00:00
|
|
|
.feature_table = features,
|
|
|
|
.feature_table_size = ARRAY_SIZE(features),
|
2007-10-22 01:03:39 +00:00
|
|
|
.driver.name = KBUILD_MODNAME,
|
|
|
|
.driver.owner = THIS_MODULE,
|
|
|
|
.id_table = id_table,
|
|
|
|
.probe = virtcons_probe,
|
2010-02-12 05:02:16 +00:00
|
|
|
.remove = virtcons_remove,
|
2009-12-21 16:52:08 +00:00
|
|
|
.config_changed = config_intr,
|
2007-10-22 01:03:39 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init init(void)
|
|
|
|
{
|
2009-12-21 16:06:04 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
|
|
|
|
if (IS_ERR(pdrvdata.class)) {
|
|
|
|
err = PTR_ERR(pdrvdata.class);
|
|
|
|
pr_err("Error %d creating virtio-ports class\n", err);
|
|
|
|
return err;
|
|
|
|
}
|
2009-12-21 17:06:21 +00:00
|
|
|
|
|
|
|
pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
|
|
|
|
if (!pdrvdata.debugfs_dir) {
|
|
|
|
pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
|
|
|
|
PTR_ERR(pdrvdata.debugfs_dir));
|
|
|
|
}
|
2010-01-18 13:45:05 +00:00
|
|
|
INIT_LIST_HEAD(&pdrvdata.consoles);
|
2010-09-02 12:41:49 +00:00
|
|
|
INIT_LIST_HEAD(&pdrvdata.portdevs);
|
2010-01-18 13:45:05 +00:00
|
|
|
|
2007-10-22 01:03:39 +00:00
|
|
|
return register_virtio_driver(&virtio_console);
|
|
|
|
}
|
2010-02-12 05:02:16 +00:00
|
|
|
|
|
|
|
static void __exit fini(void)
|
|
|
|
{
|
|
|
|
unregister_virtio_driver(&virtio_console);
|
|
|
|
|
|
|
|
class_destroy(pdrvdata.class);
|
|
|
|
if (pdrvdata.debugfs_dir)
|
|
|
|
debugfs_remove_recursive(pdrvdata.debugfs_dir);
|
|
|
|
}
|
2007-10-22 01:03:39 +00:00
|
|
|
module_init(init);
|
2010-02-12 05:02:16 +00:00
|
|
|
module_exit(fini);
|
2007-10-22 01:03:39 +00:00
|
|
|
|
|
|
|
MODULE_DEVICE_TABLE(virtio, id_table);
|
|
|
|
MODULE_DESCRIPTION("Virtio console driver");
|
|
|
|
MODULE_LICENSE("GPL");
|