/*
|
* Copyright (C) 2010 Philippe Gerum <rpm@xenomai.org>
|
*
|
* 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.
|
*/
|
#include <linux/stdarg.h>
|
#include <linux/ctype.h>
|
#include <linux/uaccess.h>
|
#include <linux/module.h>
|
#include <linux/slab.h>
|
#include <cobalt/kernel/lock.h>
|
#include <cobalt/kernel/assert.h>
|
#include <cobalt/kernel/vfile.h>
|
#include <asm/xenomai/wrappers.h>
|
|
/**
|
* @ingroup cobalt_core
|
* @defgroup cobalt_core_vfile Virtual file services
|
*
|
* Virtual files provide a mean to export Xenomai object states to
|
* user-space, based on common kernel interfaces. This encapsulation
|
* is aimed at:
|
*
|
* - supporting consistent collection of very large record-based
|
* output, without encurring latency peaks for undergoing real-time
|
* activities.
|
*
|
* - in the future, hiding discrepancies between linux kernel
|
* releases, regarding the proper way to export kernel object states
|
* to userland, either via the /proc interface or by any other mean.
|
*
|
* This virtual file implementation offers record-based read support
|
* based on seq_files, single-buffer write support, directory and link
|
* handling, all visible from the /proc namespace.
|
*
|
* The vfile support exposes four filesystem object types:
|
*
|
* - snapshot-driven file (struct xnvfile_snapshot). This is commonly
|
* used to export real-time object states via the /proc filesystem. To
|
* minimize the latency involved in protecting the vfile routines from
|
* changes applied by real-time code on such objects, a snapshot of
|
* the data to output is first taken under proper locking, before the
|
* collected data is formatted and sent out in a lockless manner.
|
*
|
* Because a large number of records may have to be output, the data
|
* collection phase is not strictly atomic as a whole, but only
|
* protected at record level. The vfile implementation can be notified
|
* of updates to the underlying data set, and restart the collection
|
* from scratch until the snapshot is fully consistent.
|
*
|
* - regular sequential file (struct xnvfile_regular). This is
|
* basically an encapsulated sequential file object as available from
|
* the host kernel (i.e. seq_file), with a few additional features to
|
* make it more handy in a Xenomai environment, like implicit locking
|
* support and shortened declaration for simplest, single-record
|
* output.
|
*
|
* - virtual link (struct xnvfile_link). This is a symbolic link
|
* feature integrated with the vfile semantics. The link target is
|
* computed dynamically at creation time from a user-given helper
|
* routine.
|
*
|
* - virtual directory (struct xnvfile_directory). A directory object,
|
* which can be used to create a hierarchy for ordering a set of vfile
|
* objects.
|
*
|
*@{*/
|
|
/**
|
* @var struct xnvfile_directory cobalt_vfroot
|
* @brief Xenomai vfile root directory
|
*
|
* This vdir maps the /proc/xenomai directory. It can be used to
|
* create a hierarchy of Xenomai-related vfiles under this root.
|
*/
|
struct xnvfile_directory cobalt_vfroot;
|
EXPORT_SYMBOL_GPL(cobalt_vfroot);
|
|
static struct xnvfile_directory sysroot;
|
|
static void *vfile_snapshot_start(struct seq_file *seq, loff_t *offp)
|
{
|
struct xnvfile_snapshot_iterator *it = seq->private;
|
loff_t pos = *offp;
|
|
if (pos > it->nrdata)
|
return NULL;
|
|
if (pos == 0)
|
return SEQ_START_TOKEN;
|
|
return it->databuf + (pos - 1) * it->vfile->datasz;
|
}
|
|
static void *vfile_snapshot_next(struct seq_file *seq, void *v, loff_t *offp)
|
{
|
struct xnvfile_snapshot_iterator *it = seq->private;
|
loff_t pos = *offp;
|
|
++*offp;
|
|
if (pos >= it->nrdata)
|
return NULL;
|
|
return it->databuf + pos * it->vfile->datasz;
|
}
|
|
static void vfile_snapshot_stop(struct seq_file *seq, void *v)
|
{
|
}
|
|
static int vfile_snapshot_show(struct seq_file *seq, void *v)
|
{
|
struct xnvfile_snapshot_iterator *it = seq->private;
|
void *data = v == SEQ_START_TOKEN ? NULL : v;
|
int ret;
|
|
ret = it->vfile->ops->show(it, data);
|
|
return ret == VFILE_SEQ_SKIP ? SEQ_SKIP : ret;
|
}
|
|
static struct seq_operations vfile_snapshot_ops = {
|
.start = vfile_snapshot_start,
|
.next = vfile_snapshot_next,
|
.stop = vfile_snapshot_stop,
|
.show = vfile_snapshot_show
|
};
|
|
static void vfile_snapshot_free(struct xnvfile_snapshot_iterator *it, void *buf)
|
{
|
kfree(buf);
|
}
|
|
static int vfile_snapshot_open(struct inode *inode, struct file *file)
|
{
|
struct xnvfile_snapshot *vfile = pde_data(inode);
|
struct xnvfile_snapshot_ops *ops = vfile->ops;
|
struct xnvfile_snapshot_iterator *it;
|
int revtag, ret, nrdata;
|
struct seq_file *seq;
|
caddr_t data;
|
|
WARN_ON_ONCE(file->private_data != NULL);
|
|
if ((file->f_mode & FMODE_WRITE) != 0 && ops->store == NULL)
|
return -EACCES;
|
|
/*
|
* Make sure to create the seq_file backend only when reading
|
* from the v-file is possible.
|
*/
|
if ((file->f_mode & FMODE_READ) == 0) {
|
file->private_data = NULL;
|
return 0;
|
}
|
|
if ((file->f_flags & O_EXCL) != 0 && xnvfile_nref(vfile) > 0)
|
return -EBUSY;
|
|
it = kzalloc(sizeof(*it) + vfile->privsz, GFP_KERNEL);
|
if (it == NULL)
|
return -ENOMEM;
|
|
it->vfile = vfile;
|
xnvfile_file(vfile) = file;
|
|
ret = vfile->entry.lockops->get(&vfile->entry);
|
if (ret)
|
goto fail;
|
redo:
|
/*
|
* The ->rewind() method is optional; there may be cases where
|
* we don't have to take an atomic snapshot of the v-file
|
* contents before proceeding. In case ->rewind() detects a
|
* stale backend object, it can force us to bail out.
|
*
|
* If present, ->rewind() may return a strictly positive
|
* value, indicating how many records at most may be returned
|
* by ->next(). We use this hint to allocate the snapshot
|
* buffer, in case ->begin() is not provided. The size of this
|
* buffer would then be vfile->datasz * hint value.
|
*
|
* If ->begin() is given, we always expect the latter do the
|
* allocation for us regardless of the hint value. Otherwise,
|
* a NULL return from ->rewind() tells us that the vfile won't
|
* output any snapshot data via ->show().
|
*/
|
nrdata = 0;
|
if (ops->rewind) {
|
nrdata = ops->rewind(it);
|
if (nrdata < 0) {
|
ret = nrdata;
|
vfile->entry.lockops->put(&vfile->entry);
|
goto fail;
|
}
|
}
|
revtag = vfile->tag->rev;
|
|
vfile->entry.lockops->put(&vfile->entry);
|
|
/* Release the data buffer, in case we had to restart. */
|
if (it->databuf) {
|
it->endfn(it, it->databuf);
|
it->databuf = NULL;
|
}
|
|
/*
|
* Having no record to output is fine, in which case ->begin()
|
* shall return VFILE_SEQ_EMPTY if present. ->begin() may be
|
* absent, meaning that no allocation is even required to
|
* collect the records to output. NULL is kept for allocation
|
* errors in all other cases.
|
*/
|
if (ops->begin) {
|
XENO_BUG_ON(COBALT, ops->end == NULL);
|
data = ops->begin(it);
|
if (data == NULL) {
|
kfree(it);
|
return -ENOMEM;
|
}
|
if (data != VFILE_SEQ_EMPTY) {
|
it->databuf = data;
|
it->endfn = ops->end;
|
}
|
} else if (nrdata > 0 && vfile->datasz > 0) {
|
/* We have a hint for auto-allocation. */
|
data = kmalloc(vfile->datasz * nrdata, GFP_KERNEL);
|
if (data == NULL) {
|
kfree(it);
|
return -ENOMEM;
|
}
|
it->databuf = data;
|
it->endfn = vfile_snapshot_free;
|
}
|
|
it->nrdata = 0;
|
data = it->databuf;
|
if (data == NULL)
|
goto done;
|
|
/*
|
* Take a snapshot of the vfile contents, redo if the revision
|
* tag of the scanned data set changed concurrently.
|
*/
|
for (;;) {
|
ret = vfile->entry.lockops->get(&vfile->entry);
|
if (ret)
|
goto fail;
|
if (vfile->tag->rev != revtag)
|
goto redo;
|
ret = ops->next(it, data);
|
vfile->entry.lockops->put(&vfile->entry);
|
if (ret < 0)
|
goto fail;
|
if (ret == 0)
|
break;
|
if (ret != VFILE_SEQ_SKIP) {
|
data += vfile->datasz;
|
it->nrdata++;
|
}
|
}
|
|
done:
|
ret = seq_open(file, &vfile_snapshot_ops);
|
if (ret)
|
goto fail;
|
|
seq = file->private_data;
|
it->seq = seq;
|
seq->private = it;
|
xnvfile_nref(vfile)++;
|
|
return 0;
|
|
fail:
|
if (it->databuf)
|
it->endfn(it, it->databuf);
|
kfree(it);
|
|
return ret;
|
}
|
|
static int vfile_snapshot_release(struct inode *inode, struct file *file)
|
{
|
struct seq_file *seq = file->private_data;
|
struct xnvfile_snapshot_iterator *it;
|
|
if (seq) {
|
it = seq->private;
|
if (it) {
|
--xnvfile_nref(it->vfile);
|
XENO_BUG_ON(COBALT, it->vfile->entry.refcnt < 0);
|
if (it->databuf)
|
it->endfn(it, it->databuf);
|
kfree(it);
|
}
|
|
return seq_release(inode, file);
|
}
|
|
return 0;
|
}
|
|
ssize_t vfile_snapshot_write(struct file *file, const char __user *buf,
|
size_t size, loff_t *ppos)
|
{
|
struct xnvfile_snapshot *vfile =
|
pde_data(file->f_path.dentry->d_inode);
|
struct xnvfile_input input;
|
ssize_t ret;
|
|
if (vfile->entry.lockops) {
|
ret = vfile->entry.lockops->get(&vfile->entry);
|
if (ret)
|
return ret;
|
}
|
|
input.u_buf = buf;
|
input.size = size;
|
input.vfile = &vfile->entry;
|
|
ret = vfile->ops->store(&input);
|
|
if (vfile->entry.lockops)
|
vfile->entry.lockops->put(&vfile->entry);
|
|
return ret;
|
}
|
|
static const DEFINE_PROC_OPS(vfile_snapshot_fops,
|
vfile_snapshot_open,
|
vfile_snapshot_release,
|
seq_read,
|
vfile_snapshot_write);
|
|
/**
|
* @fn int xnvfile_init_snapshot(const char *name, struct xnvfile_snapshot *vfile, struct xnvfile_directory *parent)
|
* @brief Initialize a snapshot-driven vfile.
|
*
|
* @param name The name which should appear in the pseudo-filesystem,
|
* identifying the vfile entry.
|
*
|
* @param vfile A pointer to a vfile descriptor to initialize
|
* from. The following fields in this structure should be filled in
|
* prior to call this routine:
|
*
|
* - .privsz is the size (in bytes) of the private data area to be
|
* reserved in the @ref snapshot_iterator "vfile iterator". A NULL
|
* value indicates that no private area should be reserved.
|
*
|
* - .datasz is the size (in bytes) of a single record to be collected
|
* by the @ref snapshot_next "next() handler" from the @ref
|
* snapshot_ops "operation descriptor".
|
*
|
* - .tag is a pointer to a mandatory vfile revision tag structure
|
* (struct xnvfile_rev_tag). This tag will be monitored for changes by
|
* the vfile core while collecting data to output, so that any update
|
* detected will cause the current snapshot data to be dropped, and
|
* the collection to restart from the beginning. To this end, any
|
* change to the data which may be part of the collected records,
|
* should also invoke xnvfile_touch() on the associated tag.
|
*
|
* - entry.lockops is a pointer to a @ref vfile_lockops "lock descriptor",
|
* defining the lock and unlock operations for the vfile. This pointer
|
* may be left to NULL, in which case the operations on the nucleus
|
* lock (i.e. nklock) will be used internally around calls to data
|
* collection handlers (see @ref snapshot_ops "operation descriptor").
|
*
|
* - .ops is a pointer to an @ref snapshot_ops "operation descriptor".
|
*
|
* @param parent A pointer to a virtual directory descriptor; the
|
* vfile entry will be created into this directory. If NULL, the /proc
|
* root directory will be used. /proc/xenomai is mapped on the
|
* globally available @a cobalt_vfroot vdir.
|
*
|
* @return 0 is returned on success. Otherwise:
|
*
|
* - -ENOMEM is returned if the virtual file entry cannot be created
|
* in the /proc hierarchy.
|
*
|
* @coretags{secondary-only}
|
*/
|
int xnvfile_init_snapshot(const char *name,
|
struct xnvfile_snapshot *vfile,
|
struct xnvfile_directory *parent)
|
{
|
struct proc_dir_entry *ppde, *pde;
|
int mode;
|
|
XENO_BUG_ON(COBALT, vfile->tag == NULL);
|
|
if (vfile->entry.lockops == NULL)
|
/* Defaults to nucleus lock */
|
vfile->entry.lockops = &xnvfile_nucleus_lock.ops;
|
|
if (parent == NULL)
|
parent = &sysroot;
|
|
mode = vfile->ops->store ? 0644 : 0444;
|
ppde = parent->entry.pde;
|
pde = proc_create_data(name, mode, ppde, &vfile_snapshot_fops, vfile);
|
if (pde == NULL)
|
return -ENOMEM;
|
|
vfile->entry.pde = pde;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_init_snapshot);
|
|
static void *vfile_regular_start(struct seq_file *seq, loff_t *offp)
|
{
|
struct xnvfile_regular_iterator *it = seq->private;
|
struct xnvfile_regular *vfile = it->vfile;
|
int ret;
|
|
it->pos = *offp;
|
|
if (vfile->entry.lockops) {
|
ret = vfile->entry.lockops->get(&vfile->entry);
|
if (ret)
|
return ERR_PTR(ret);
|
}
|
|
/*
|
* If we have no begin() op, then we allow a single call only
|
* to ->show(), by returning the start token once. Otherwise,
|
* we are done.
|
*/
|
if (vfile->ops->begin == NULL)
|
return it->pos > 0 ? NULL : SEQ_START_TOKEN;
|
|
return vfile->ops->begin(it);
|
}
|
|
static void *vfile_regular_next(struct seq_file *seq, void *v, loff_t *offp)
|
{
|
struct xnvfile_regular_iterator *it = seq->private;
|
struct xnvfile_regular *vfile = it->vfile;
|
void *data;
|
|
it->pos = ++(*offp);
|
|
if (vfile->ops->next == NULL)
|
return NULL;
|
|
data = vfile->ops->next(it);
|
if (data == NULL)
|
return NULL;
|
|
return data;
|
}
|
|
static void vfile_regular_stop(struct seq_file *seq, void *v)
|
{
|
struct xnvfile_regular_iterator *it = seq->private;
|
struct xnvfile_regular *vfile = it->vfile;
|
|
if (vfile->entry.lockops)
|
vfile->entry.lockops->put(&vfile->entry);
|
|
if (vfile->ops->end)
|
vfile->ops->end(it);
|
}
|
|
static int vfile_regular_show(struct seq_file *seq, void *v)
|
{
|
struct xnvfile_regular_iterator *it = seq->private;
|
struct xnvfile_regular *vfile = it->vfile;
|
void *data = v == SEQ_START_TOKEN ? NULL : v;
|
int ret;
|
|
ret = vfile->ops->show(it, data);
|
|
return ret == VFILE_SEQ_SKIP ? SEQ_SKIP : ret;
|
}
|
|
static struct seq_operations vfile_regular_ops = {
|
.start = vfile_regular_start,
|
.next = vfile_regular_next,
|
.stop = vfile_regular_stop,
|
.show = vfile_regular_show
|
};
|
|
static int vfile_regular_open(struct inode *inode, struct file *file)
|
{
|
struct xnvfile_regular *vfile = pde_data(inode);
|
struct xnvfile_regular_ops *ops = vfile->ops;
|
struct xnvfile_regular_iterator *it;
|
struct seq_file *seq;
|
int ret;
|
|
if ((file->f_flags & O_EXCL) != 0 && xnvfile_nref(vfile) > 0)
|
return -EBUSY;
|
|
if ((file->f_mode & FMODE_WRITE) != 0 && ops->store == NULL)
|
return -EACCES;
|
|
if ((file->f_mode & FMODE_READ) == 0) {
|
file->private_data = NULL;
|
return 0;
|
}
|
|
it = kzalloc(sizeof(*it) + vfile->privsz, GFP_KERNEL);
|
if (it == NULL)
|
return -ENOMEM;
|
|
it->vfile = vfile;
|
it->pos = -1;
|
xnvfile_file(vfile) = file;
|
|
if (ops->rewind) {
|
ret = ops->rewind(it);
|
if (ret) {
|
fail:
|
kfree(it);
|
return ret;
|
}
|
}
|
|
ret = seq_open(file, &vfile_regular_ops);
|
if (ret)
|
goto fail;
|
|
seq = file->private_data;
|
it->seq = seq;
|
seq->private = it;
|
xnvfile_nref(vfile)++;
|
|
return 0;
|
}
|
|
static int vfile_regular_release(struct inode *inode, struct file *file)
|
{
|
struct seq_file *seq = file->private_data;
|
struct xnvfile_regular_iterator *it;
|
|
if (seq) {
|
it = seq->private;
|
if (it) {
|
--xnvfile_nref(it->vfile);
|
XENO_BUG_ON(COBALT, xnvfile_nref(it->vfile) < 0);
|
kfree(it);
|
}
|
|
return seq_release(inode, file);
|
}
|
|
return 0;
|
}
|
|
ssize_t vfile_regular_write(struct file *file, const char __user *buf,
|
size_t size, loff_t *ppos)
|
{
|
struct xnvfile_regular *vfile =
|
pde_data(file->f_path.dentry->d_inode);
|
struct xnvfile_input input;
|
ssize_t ret;
|
|
if (vfile->entry.lockops) {
|
ret = vfile->entry.lockops->get(&vfile->entry);
|
if (ret)
|
return ret;
|
}
|
|
input.u_buf = buf;
|
input.size = size;
|
input.vfile = &vfile->entry;
|
|
ret = vfile->ops->store(&input);
|
|
if (vfile->entry.lockops)
|
vfile->entry.lockops->put(&vfile->entry);
|
|
return ret;
|
}
|
|
static const DEFINE_PROC_OPS(vfile_regular_fops,
|
vfile_regular_open,
|
vfile_regular_release,
|
seq_read,
|
vfile_regular_write);
|
|
/**
|
* @fn int xnvfile_init_regular(const char *name, struct xnvfile_regular *vfile, struct xnvfile_directory *parent)
|
* @brief Initialize a regular vfile.
|
*
|
* @param name The name which should appear in the pseudo-filesystem,
|
* identifying the vfile entry.
|
*
|
* @param vfile A pointer to a vfile descriptor to initialize
|
* from. The following fields in this structure should be filled in
|
* prior to call this routine:
|
*
|
* - .privsz is the size (in bytes) of the private data area to be
|
* reserved in the @ref regular_iterator "vfile iterator". A NULL
|
* value indicates that no private area should be reserved.
|
*
|
* - entry.lockops is a pointer to a @ref vfile_lockops "locking
|
* descriptor", defining the lock and unlock operations for the
|
* vfile. This pointer may be left to NULL, in which case no
|
* locking will be applied.
|
*
|
* - .ops is a pointer to an @ref regular_ops "operation descriptor".
|
*
|
* @param parent A pointer to a virtual directory descriptor; the
|
* vfile entry will be created into this directory. If NULL, the /proc
|
* root directory will be used. /proc/xenomai is mapped on the
|
* globally available @a cobalt_vfroot vdir.
|
*
|
* @return 0 is returned on success. Otherwise:
|
*
|
* - -ENOMEM is returned if the virtual file entry cannot be created
|
* in the /proc hierarchy.
|
*
|
* @coretags{secondary-only}
|
*/
|
int xnvfile_init_regular(const char *name,
|
struct xnvfile_regular *vfile,
|
struct xnvfile_directory *parent)
|
{
|
struct proc_dir_entry *ppde, *pde;
|
int mode;
|
|
if (parent == NULL)
|
parent = &sysroot;
|
|
mode = vfile->ops->store ? 0644 : 0444;
|
ppde = parent->entry.pde;
|
pde = proc_create_data(name, mode, ppde, &vfile_regular_fops, vfile);
|
if (pde == NULL)
|
return -ENOMEM;
|
|
vfile->entry.pde = pde;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_init_regular);
|
|
/**
|
* @fn int xnvfile_init_dir(const char *name, struct xnvfile_directory *vdir, struct xnvfile_directory *parent)
|
* @brief Initialize a virtual directory entry.
|
*
|
* @param name The name which should appear in the pseudo-filesystem,
|
* identifying the vdir entry.
|
*
|
* @param vdir A pointer to the virtual directory descriptor to
|
* initialize.
|
*
|
* @param parent A pointer to a virtual directory descriptor standing
|
* for the parent directory of the new vdir. If NULL, the /proc root
|
* directory will be used. /proc/xenomai is mapped on the globally
|
* available @a cobalt_vfroot vdir.
|
*
|
* @return 0 is returned on success. Otherwise:
|
*
|
* - -ENOMEM is returned if the virtual directory entry cannot be
|
* created in the /proc hierarchy.
|
*
|
* @coretags{secondary-only}
|
*/
|
int xnvfile_init_dir(const char *name,
|
struct xnvfile_directory *vdir,
|
struct xnvfile_directory *parent)
|
{
|
struct proc_dir_entry *ppde, *pde;
|
|
if (parent == NULL)
|
parent = &sysroot;
|
|
ppde = parent->entry.pde;
|
pde = proc_mkdir(name, ppde);
|
if (pde == NULL)
|
return -ENOMEM;
|
|
vdir->entry.pde = pde;
|
vdir->entry.lockops = NULL;
|
vdir->entry.private = NULL;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_init_dir);
|
|
/**
|
* @fn int xnvfile_init_link(const char *from, const char *to, struct xnvfile_link *vlink, struct xnvfile_directory *parent)
|
* @brief Initialize a virtual link entry.
|
*
|
* @param from The name which should appear in the pseudo-filesystem,
|
* identifying the vlink entry.
|
*
|
* @param to The target file name which should be referred to
|
* symbolically by @a name.
|
*
|
* @param vlink A pointer to the virtual link descriptor to
|
* initialize.
|
*
|
* @param parent A pointer to a virtual directory descriptor standing
|
* for the parent directory of the new vlink. If NULL, the /proc root
|
* directory will be used. /proc/xenomai is mapped on the globally
|
* available @a cobalt_vfroot vdir.
|
*
|
* @return 0 is returned on success. Otherwise:
|
*
|
* - -ENOMEM is returned if the virtual link entry cannot be created
|
* in the /proc hierarchy.
|
*
|
* @coretags{secondary-only}
|
*/
|
int xnvfile_init_link(const char *from,
|
const char *to,
|
struct xnvfile_link *vlink,
|
struct xnvfile_directory *parent)
|
{
|
struct proc_dir_entry *ppde, *pde;
|
|
if (parent == NULL)
|
parent = &sysroot;
|
|
ppde = parent->entry.pde;
|
pde = proc_symlink(from, ppde, to);
|
if (pde == NULL)
|
return -ENOMEM;
|
|
vlink->entry.pde = pde;
|
vlink->entry.lockops = NULL;
|
vlink->entry.private = NULL;
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_init_link);
|
|
/**
|
* @fn void xnvfile_destroy(struct xnvfile *vfile)
|
* @brief Removes a virtual file entry.
|
*
|
* @param vfile A pointer to the virtual file descriptor to
|
* remove.
|
*
|
* @coretags{secondary-only}
|
*/
|
void xnvfile_destroy(struct xnvfile *vfile)
|
{
|
proc_remove(vfile->pde);
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_destroy);
|
|
/**
|
* @fn ssize_t xnvfile_get_blob(struct xnvfile_input *input, void *data, size_t size)
|
* @brief Read in a data bulk written to the vfile.
|
*
|
* When writing to a vfile, the associated store() handler from the
|
* @ref snapshot_store "snapshot-driven vfile" or @ref regular_store
|
* "regular vfile" is called, with a single argument describing the
|
* input data. xnvfile_get_blob() retrieves this data as an untyped
|
* binary blob, and copies it back to the caller's buffer.
|
*
|
* @param input A pointer to the input descriptor passed to the
|
* store() handler.
|
*
|
* @param data The address of the destination buffer to copy the input
|
* data to.
|
*
|
* @param size The maximum number of bytes to copy to the destination
|
* buffer. If @a size is larger than the actual data size, the input
|
* is truncated to @a size.
|
*
|
* @return The number of bytes read and copied to the destination
|
* buffer upon success. Otherwise, a negative error code is returned:
|
*
|
* - -EFAULT indicates an invalid source buffer address.
|
*
|
* @coretags{secondary-only}
|
*/
|
ssize_t xnvfile_get_blob(struct xnvfile_input *input,
|
void *data, size_t size)
|
{
|
ssize_t nbytes = input->size;
|
|
if (nbytes > size)
|
nbytes = size;
|
|
if (nbytes > 0 && copy_from_user(data, input->u_buf, nbytes))
|
return -EFAULT;
|
|
return nbytes;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_get_blob);
|
|
/**
|
* @fn ssize_t xnvfile_get_string(struct xnvfile_input *input, char *s, size_t maxlen)
|
* @brief Read in a C-string written to the vfile.
|
*
|
* When writing to a vfile, the associated store() handler from the
|
* @ref snapshot_store "snapshot-driven vfile" or @ref regular_store
|
* "regular vfile" is called, with a single argument describing the
|
* input data. xnvfile_get_string() retrieves this data as a
|
* null-terminated character string, and copies it back to the
|
* caller's buffer.
|
*
|
* @param input A pointer to the input descriptor passed to the
|
* store() handler.
|
*
|
* @param s The address of the destination string buffer to copy the
|
* input data to.
|
*
|
* @param maxlen The maximum number of bytes to copy to the
|
* destination buffer, including the ending null character. If @a
|
* maxlen is larger than the actual string length, the input is
|
* truncated to @a maxlen.
|
*
|
* @return The number of characters read upon success. Otherwise, a
|
* negative error code is returned:
|
*
|
* - -EFAULT indicates an invalid source buffer address.
|
*
|
* @coretags{secondary-only}
|
*/
|
ssize_t xnvfile_get_string(struct xnvfile_input *input,
|
char *s, size_t maxlen)
|
{
|
ssize_t nbytes, eol;
|
|
if (maxlen < 1)
|
return -EINVAL;
|
|
nbytes = xnvfile_get_blob(input, s, maxlen - 1);
|
if (nbytes < 0)
|
return nbytes;
|
|
eol = nbytes;
|
if (eol > 0 && s[eol - 1] == '\n')
|
eol--;
|
|
s[eol] = '\0';
|
|
return nbytes;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_get_string);
|
|
/**
|
* @fn ssize_t xnvfile_get_integer(struct xnvfile_input *input, long *valp)
|
* @brief Evaluate the string written to the vfile as a long integer.
|
*
|
* When writing to a vfile, the associated store() handler from the
|
* @ref snapshot_store "snapshot-driven vfile" or @ref regular_store
|
* "regular vfile" is called, with a single argument describing the
|
* input data. xnvfile_get_integer() retrieves and interprets this
|
* data as a long integer, and copies the resulting value back to @a
|
* valp.
|
*
|
* The long integer can be expressed in decimal, octal or hexadecimal
|
* bases depending on the prefix found.
|
*
|
* @param input A pointer to the input descriptor passed to the
|
* store() handler.
|
*
|
* @param valp The address of a long integer variable to receive the
|
* value.
|
*
|
* @return The number of characters read while evaluating the input as
|
* a long integer upon success. Otherwise, a negative error code is
|
* returned:
|
*
|
* - -EINVAL indicates a parse error on the input stream; the written
|
* text cannot be evaluated as a long integer.
|
*
|
* - -EFAULT indicates an invalid source buffer address.
|
*
|
* @coretags{secondary-only}
|
*/
|
ssize_t xnvfile_get_integer(struct xnvfile_input *input, long *valp)
|
{
|
char *end, buf[32];
|
ssize_t nbytes;
|
long val;
|
|
nbytes = xnvfile_get_blob(input, buf, sizeof(buf) - 1);
|
if (nbytes < 0)
|
return nbytes;
|
|
if (nbytes == 0)
|
return -EINVAL;
|
|
buf[nbytes] = '\0';
|
val = simple_strtol(buf, &end, 0);
|
|
if (*end != '\0' && !isspace(*end))
|
return -EINVAL;
|
|
*valp = val;
|
|
return nbytes;
|
}
|
EXPORT_SYMBOL_GPL(xnvfile_get_integer);
|
|
int __vfile_hostlock_get(struct xnvfile *vfile)
|
{
|
struct xnvfile_hostlock_class *lc;
|
|
lc = container_of(vfile->lockops, struct xnvfile_hostlock_class, ops);
|
mutex_lock(&lc->mutex);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(__vfile_hostlock_get);
|
|
void __vfile_hostlock_put(struct xnvfile *vfile)
|
{
|
struct xnvfile_hostlock_class *lc;
|
|
lc = container_of(vfile->lockops, struct xnvfile_hostlock_class, ops);
|
mutex_unlock(&lc->mutex);
|
}
|
EXPORT_SYMBOL_GPL(__vfile_hostlock_put);
|
|
static int __vfile_nklock_get(struct xnvfile *vfile)
|
{
|
struct xnvfile_nklock_class *lc;
|
|
lc = container_of(vfile->lockops, struct xnvfile_nklock_class, ops);
|
xnlock_get_irqsave(&nklock, lc->s);
|
|
return 0;
|
}
|
|
static void __vfile_nklock_put(struct xnvfile *vfile)
|
{
|
struct xnvfile_nklock_class *lc;
|
|
lc = container_of(vfile->lockops, struct xnvfile_nklock_class, ops);
|
xnlock_put_irqrestore(&nklock, lc->s);
|
}
|
|
struct xnvfile_nklock_class xnvfile_nucleus_lock = {
|
.ops = {
|
.get = __vfile_nklock_get,
|
.put = __vfile_nklock_put,
|
},
|
};
|
|
int __init xnvfile_init_root(void)
|
{
|
struct xnvfile_directory *vdir = &cobalt_vfroot;
|
struct proc_dir_entry *pde;
|
|
pde = proc_mkdir("xenomai", NULL);
|
if (pde == NULL)
|
return -ENOMEM;
|
|
vdir->entry.pde = pde;
|
vdir->entry.lockops = NULL;
|
vdir->entry.private = NULL;
|
|
return 0;
|
}
|
|
void xnvfile_destroy_root(void)
|
{
|
cobalt_vfroot.entry.pde = NULL;
|
remove_proc_entry("xenomai", NULL);
|
}
|
|
/** @} */
|
