Module: xenomai-rpm
Branch: queue/vfile
Commit: 721e9c6dc139063329c2af2e6b9415e37e36f44b
URL:    
http://git.xenomai.org/?p=xenomai-rpm.git;a=commit;h=721e9c6dc139063329c2af2e6b9415e37e36f44b

Author: Philippe Gerum <r...@xenomai.org>
Date:   Tue May 25 17:36:56 2010 +0200

nucleus: introduce virtual file support

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.

---

 include/nucleus/vfile.h |  276 +++++++++++++++++++++++
 ksrc/nucleus/vfile.c    |  557 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 833 insertions(+), 0 deletions(-)

diff --git a/include/nucleus/vfile.h b/include/nucleus/vfile.h
new file mode 100644
index 0000000..5a95c4e
--- /dev/null
+++ b/include/nucleus/vfile.h
@@ -0,0 +1,276 @@
+/**
+ * @file
+ * This file is part of the Xenomai project.
+ *
+ * @note Copyright (C) 2010 Philippe Gerum <r...@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.
+ *
+ * \ingroup vfile
+ */
+
+#ifndef _XENO_NUCLEUS_VFILE_H
+#define _XENO_NUCLEUS_VFILE_H
+
+#ifdef CONFIG_PROC_FS
+
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <nucleus/types.h>
+
+struct xnvfile_directory;
+struct xnvfile_regular_iterator;
+struct xnvfile_snapshot_iterator;
+struct xnvfile_lock_ops;
+
+struct xnvfile {
+       struct proc_dir_entry *pde;
+       struct xnvfile_directory *parent;
+       struct xnvfile_lock_ops *lockops;
+       void *private;
+};
+
+struct xnvfile_lock_ops {
+       void (*get)(struct xnvfile *vfile);
+       void (*put)(struct xnvfile *vfile);
+};
+
+/*
+ * XXX: struct semaphore is legacy for mutual exclusion, but supported
+ * on both 2.4 and 2.6 kernels. Will be changed to mutex when 2.4
+ * support is dropped from Xenomai.
+ */
+struct xnvfile_hostlock_class {
+       struct xnvfile_lock_ops ops;
+       struct semaphore sem;
+};
+
+struct xnvfile_nklock_class {
+       struct xnvfile_lock_ops ops;
+       spl_t s;
+};
+
+struct xnvfile_input {
+       const char __user *u_buf;
+       size_t size;
+       struct xnvfile *vfile;
+};
+
+struct xnvfile_regular_ops {
+       void *(*begin)(struct xnvfile_regular_iterator *it);
+       void *(*next)(struct xnvfile_regular_iterator *it);
+       void (*end)(struct xnvfile_regular_iterator *it);
+       int (*show)(struct xnvfile_regular_iterator *it, void *data);
+       ssize_t (*store)(struct xnvfile_input *input);
+};
+
+struct xnvfile_regular {
+       struct xnvfile entry;
+       size_t privsz;
+       struct xnvfile_regular_ops *ops;
+};
+
+struct xnvfile_regular_template {
+       size_t privsz;
+       struct xnvfile_regular_ops *ops;
+       struct xnvfile_lock_ops *lockops;
+};
+
+struct xnvfile_regular_iterator {
+       loff_t pos;
+       struct seq_file *seq;
+       struct xnvfile_regular *vfile;
+       char private[0];
+};
+
+struct xnvfile_snapshot_ops {
+       int (*rewind)(struct xnvfile_snapshot_iterator *it);
+       void *(*begin)(struct xnvfile_snapshot_iterator *it);
+       int (*next)(struct xnvfile_snapshot_iterator *it, void *data);
+       void (*end)(struct xnvfile_snapshot_iterator *it, void *buf);
+       int (*show)(struct xnvfile_snapshot_iterator *it, void *data);
+       ssize_t (*store)(struct xnvfile_input *input);
+};
+
+struct xnvfile_rev_tag {
+       int rev;
+};
+
+struct xnvfile_snapshot_template {
+       size_t privsz;
+       size_t datasz;
+       struct xnvfile_rev_tag *tag;
+       struct xnvfile_snapshot_ops *ops;
+       struct xnvfile_lock_ops *lockops;
+};
+
+struct xnvfile_snapshot {
+       struct xnvfile entry;
+       size_t privsz;
+       size_t datasz;
+       struct xnvfile_rev_tag *tag;
+       struct xnvfile_snapshot_ops *ops;
+};
+
+struct xnvfile_snapshot_iterator {
+       int nrdata;
+       caddr_t databuf;
+       struct seq_file *seq;
+       struct xnvfile_snapshot *vfile;
+       char private[0];
+};
+
+struct xnvfile_directory {
+       struct xnvfile entry;
+};
+
+struct xnvfile_link {
+       struct xnvfile entry;
+};
+
+/* vfile.begin()=> */
+#define VFILE_SEQ_EMPTY                        ((void *)-1)
+/* =>vfile.show() */
+#define VFILE_SEQ_START                        SEQ_START_TOKEN
+/* vfile.next/show()=> */
+#define VFILE_SEQ_SKIP                 2
+
+#define xnvfile_printf(it, args...)    seq_printf((it)->seq, ##args)
+#define xnvfile_write(it, data, len)   seq_write((it)->seq, (data),(len))
+#define xnvfile_puts(it, s)            seq_puts((it)->seq, (s))
+#define xnvfile_putc(it, c)            seq_putc((it)->seq, (c))
+
+static inline void xnvfile_touch_tag(struct xnvfile_rev_tag *tag)
+{
+       tag->rev++;
+}
+
+static inline void xnvfile_touch(struct xnvfile_snapshot *vfile)
+{
+       xnvfile_touch_tag(vfile->tag);
+}
+
+static inline void *xnvfile_snapshot_iterator_priv(struct 
xnvfile_snapshot_iterator *it)
+{
+       return &it->private;
+}
+
+static inline int xnvfile_reg_p(struct xnvfile *entry)
+{
+       return S_ISREG(entry->pde->mode);
+}
+
+static inline int xnvfile_dir_p(struct xnvfile *entry)
+{
+       return S_ISDIR(entry->pde->mode);
+}
+
+static inline int xnvfile_link_p(struct xnvfile *entry)
+{
+       return S_ISLNK(entry->pde->mode);
+}
+
+#define xnvfile_noentry                        \
+       {                               \
+               .pde = NULL,            \
+               .parent = NULL,         \
+               .private = NULL,        \
+       }
+
+#define xnvfile_nodir  { .entry = xnvfile_noentry }
+#define xnvfile_nolink { .entry = xnvfile_noentry }
+#define xnvfile_nofile { .entry = xnvfile_noentry }
+
+#define xnvfile_parent(e)      ((e)->entry.parent)
+#define xnvfile_priv(e)                ((e)->entry.private)
+
+extern struct xnvfile_nklock_class xnvfile_nucleus_lock;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int xnvfile_init_snapshot(const char *name,
+                         struct xnvfile_snapshot *vfile,
+                         struct xnvfile_directory *parent);
+
+int xnvfile_init_regular(const char *name,
+                        struct xnvfile_regular *vfile,
+                        struct xnvfile_directory *parent);
+
+int xnvfile_init_dir(const char *name,
+                    struct xnvfile_directory *vdir,
+                    struct xnvfile_directory *parent);
+
+int xnvfile_init_link(const char *from,
+                     const char *to,
+                     struct xnvfile_link *vlink,
+                     struct xnvfile_directory *parent);
+
+void xnvfile_destroy(struct xnvfile *vfile);
+
+ssize_t xnvfile_get_blob(struct xnvfile_input *input,
+                        void *data, size_t size);
+
+void __vfile_hostlock_get(struct xnvfile *vfile);
+
+void __vfile_hostlock_put(struct xnvfile *vfile);
+
+#ifdef __cplusplus
+}
+#endif
+
+static inline
+void xnvfile_destroy_snapshot(struct xnvfile_snapshot *vfile)
+{
+       xnvfile_destroy(&vfile->entry);
+}
+
+static inline
+void xnvfile_destroy_regular(struct xnvfile_regular *vfile)
+{
+       xnvfile_destroy(&vfile->entry);
+}
+
+static inline
+void xnvfile_destroy_dir(struct xnvfile_directory *vdir)
+{
+       xnvfile_destroy(&vdir->entry);
+}
+
+static inline
+void xnvfile_destroy_link(struct xnvfile_link *vlink)
+{
+       xnvfile_destroy(&vlink->entry);
+}
+
+#define DEFINE_VFILE_HOSTLOCK(name)                                    \
+       struct xnvfile_hostlock_class name = {                          \
+               .ops = {                                                \
+                       .get = __vfile_hostlock_get,                    \
+                       .put = __vfile_hostlock_put,                    \
+               },                                                      \
+               .sem = __SEMAPHORE_INITIALIZER(name.sem, 1),            \
+       }
+
+#else /* !CONFIG_PROC_FS */
+
+#define xnvfile_touch_tag(tag) do { } while (0)
+
+#define xnvfile_touch(vfile)   do { } while (0)
+
+#endif /* !CONFIG_PROC_FS */
+
+#endif /* !_XENO_NUCLEUS_VFILE_H */
diff --git a/ksrc/nucleus/vfile.c b/ksrc/nucleus/vfile.c
new file mode 100644
index 0000000..e5b0a78
--- /dev/null
+++ b/ksrc/nucleus/vfile.c
@@ -0,0 +1,557 @@
+/**
+ * @file
+ * This file is part of the Xenomai project.
+ *
+ * @note Copyright (C) 2010 Philippe Gerum <r...@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.
+ *
+ * \ingroup vfile
+ */
+
+/*!
+ * \ingroup nucleus
+ * \defgroup 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.
+ *
+ *...@{*/
+
+#include <stdarg.h>
+#include <nucleus/pod.h>
+#include <nucleus/assert.h>
+#include <nucleus/vfile.h>
+
+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;
+
+       if (pos > it->nrdata)
+               return NULL;
+
+       return it->databuf + (pos - 1) * 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 int vfile_snapshot_open(struct inode *inode, struct file *file)
+{
+       struct proc_dir_entry *pde = PDE(inode);
+       struct xnvfile_snapshot *vfile = pde->data;
+       struct xnvfile_snapshot_ops *ops = vfile->ops;
+       struct xnvfile_snapshot_iterator *it;
+       struct seq_file *seq;
+       int revtag, ret;
+       caddr_t data;
+
+       /*
+        * There is no point in reading/writing to v-files that must
+        * be connected to Xenomai resources if the system has not
+        * been initialized yet (i.e. xnpod_init() called).
+        */
+       if (!xnpod_active_p())
+               return -ESRCH;
+
+       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;
+       }
+
+       it = kzalloc(sizeof(*it) + vfile->privsz, GFP_KERNEL);
+       if (it == NULL)
+               return -ENOMEM;
+
+       it->vfile = vfile;
+
+       vfile->entry.lockops->get(&vfile->entry);
+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 (ops->rewind) {
+               ret = ops->rewind(it);
+               if (ret) {
+                       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)
+               ops->end(it, it->databuf);
+
+       /*
+        * 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.
+        */
+       it->databuf = NULL;
+       if (ops->begin) {
+               data = ops->begin(it);
+               if (data == NULL) {
+                       kfree(it);
+                       return -ENOMEM;
+               }
+               if (data != VFILE_SEQ_EMPTY)
+                       it->databuf = data;
+       }
+
+       ret = seq_open(file, &vfile_snapshot_ops);
+       if (ret)
+               goto fail;
+
+       it->nrdata = 0;
+       data = it->databuf;
+       if (data == NULL)
+               goto finish;
+
+       /*
+        * Take a snapshot of the vfile contents, redo if the revision
+        * tag of the scanned data set changed concurrently.
+        */
+       for (;;) {
+               vfile->entry.lockops->get(&vfile->entry);
+               if (vfile->tag->rev != revtag)
+                       goto redo;
+               ret = ops->next(it, data);
+               vfile->entry.lockops->put(&vfile->entry);
+               if (ret <= 0)
+                       break;
+               if (ret != VFILE_SEQ_SKIP) {
+                       data += vfile->datasz;
+                       it->nrdata++;
+               }
+       }
+
+       if (ret < 0) {
+               seq_release(inode, file);
+       fail:
+               if (it->databuf)
+                       ops->end(it, it->databuf);
+               kfree(it);
+               return ret;
+       }
+
+finish:
+       seq = file->private_data;
+       it->seq = seq;
+       seq->private = it;
+
+       return 0;
+}
+
+static int vfile_snapshot_release(struct inode *inode, struct file *file)
+{
+       struct proc_dir_entry *pde = PDE(inode);
+       struct xnvfile_snapshot *vfile = pde->data;
+       struct xnvfile_snapshot_iterator *it;
+       struct seq_file *seq = file->private_data;
+
+       if (seq) {
+               it = seq->private;
+               if (it) {
+                       if (it->databuf)
+                               vfile->ops->end(it, it->databuf);
+                       kfree(it);
+               }
+       }
+
+       return seq_release(inode, file);
+}
+
+ssize_t vfile_snapshot_write(struct file *file, const char __user *buf,
+                            size_t size, loff_t *ppos)
+{
+       struct proc_dir_entry *pde = PDE(wrap_f_inode(file));
+       struct xnvfile_snapshot *vfile = pde->data;
+       struct xnvfile_input input;
+
+       input.u_buf = buf;
+       input.size = size;
+       input.vfile = &vfile->entry;
+
+       return vfile->ops->store(&input);
+}
+
+static struct file_operations vfile_snapshot_fops = {
+       .owner = THIS_MODULE,
+       .open = vfile_snapshot_open,
+       .read = seq_read,
+       .write = vfile_snapshot_write,
+       .llseek = seq_lseek,
+       .release = vfile_snapshot_release,
+};
+
+int xnvfile_init_snapshot(const char *name,
+                         struct xnvfile_snapshot *vfile,
+                         struct xnvfile_directory *parent)
+{
+       struct proc_dir_entry *ppde, *pde;
+
+       if (vfile->entry.lockops == NULL)
+               /* Defaults to nucleus lock */
+               vfile->entry.lockops = &xnvfile_nucleus_lock.ops;
+
+       ppde = parent ? parent->entry.pde : rthal_proc_root;
+       pde = create_proc_entry(name, 0, ppde);
+       if (pde == NULL)
+               return -ENOMEM;
+
+       pde->proc_fops = &vfile_snapshot_fops;
+       wrap_proc_dir_entry_owner(pde);
+
+       vfile->entry.parent = parent;
+       vfile->entry.pde = pde;
+       pde->data = vfile;
+
+       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;
+
+       it->pos = *offp;
+
+       if (vfile->entry.lockops)
+               vfile->entry.lockops->get(&vfile->entry);
+
+       /*
+        * 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;
+       loff_t pos = ++*offp;
+
+       if (vfile->ops->next == NULL)
+               return NULL;
+
+       it->pos = pos;
+
+       return vfile->ops->next(it);
+}
+
+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 proc_dir_entry *pde = PDE(inode);
+       struct xnvfile_regular *vfile = pde->data;
+       struct xnvfile_regular_ops *ops = vfile->ops;
+       struct xnvfile_regular_iterator *it;
+       struct seq_file *seq;
+       int ret;
+
+       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;
+
+       ret = seq_open(file, &vfile_regular_ops);
+       if (ret) {
+               kfree(it);
+               return ret;
+       }
+
+       seq = file->private_data;
+       it->seq = seq;
+       seq->private = it;
+
+       return 0;
+}
+
+static int vfile_regular_release(struct inode *inode, struct file *file)
+{
+       struct xnvfile_regular_iterator *it;
+       struct seq_file *seq = file->private_data;
+
+       if (seq) {
+               it = seq->private;
+               if (it)
+                       kfree(it);
+       }
+
+       return seq_release(inode, file);
+}
+
+ssize_t vfile_regular_write(struct file *file, const char __user *buf,
+                            size_t size, loff_t *ppos)
+{
+       struct proc_dir_entry *pde = PDE(wrap_f_inode(file));
+       struct xnvfile_regular *vfile = pde->data;
+       struct xnvfile_input input;
+
+       input.u_buf = buf;
+       input.size = size;
+       input.vfile = &vfile->entry;
+
+       return vfile->ops->store(&input);
+}
+
+static struct file_operations vfile_regular_fops = {
+       .owner = THIS_MODULE,
+       .open = vfile_regular_open,
+       .read = seq_read,
+       .write = vfile_regular_write,
+       .llseek = seq_lseek,
+       .release = vfile_regular_release,
+};
+
+int xnvfile_init_regular(const char *name,
+                        struct xnvfile_regular *vfile,
+                        struct xnvfile_directory *parent)
+{
+       struct proc_dir_entry *ppde, *pde;
+
+       ppde = parent ? parent->entry.pde : rthal_proc_root;
+       pde = create_proc_entry(name, 0, ppde);
+       if (pde == NULL)
+               return -ENOMEM;
+
+       pde->proc_fops = &vfile_regular_fops;
+       wrap_proc_dir_entry_owner(pde);
+
+       vfile->entry.parent = parent;
+       vfile->entry.pde = pde;
+       pde->data = vfile;
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(xnvfile_init_regular);
+
+int xnvfile_init_dir(const char *name,
+                    struct xnvfile_directory *vdir,
+                    struct xnvfile_directory *parent)
+{
+       struct proc_dir_entry *ppde, *pde;
+
+       ppde = parent ? parent->entry.pde : rthal_proc_root;
+       pde = create_proc_entry(name, S_IFDIR, ppde);
+       if (pde == NULL)
+               return -ENOMEM;
+
+       vdir->entry.parent = parent;
+       vdir->entry.pde = pde;
+       vdir->entry.lockops = NULL;
+       vdir->entry.private = NULL;
+       wrap_proc_dir_entry_owner(pde);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(xnvfile_init_dir);
+
+int xnvfile_init_link(const char *from,
+                     const char *to,
+                     struct xnvfile_link *vlink,
+                     struct xnvfile_directory *parent)
+{
+       struct proc_dir_entry *ppde, *pde;
+
+       ppde = parent ? parent->entry.pde : rthal_proc_root;
+       pde = proc_symlink(from, ppde, to);
+       if (vlink->entry.pde == NULL)
+               return -ENOMEM;
+
+       vlink->entry.parent = parent;
+       vlink->entry.pde = pde;
+       vlink->entry.lockops = NULL;
+       vlink->entry.private = NULL;
+       wrap_proc_dir_entry_owner(pde);
+
+       return 0;
+}
+EXPORT_SYMBOL_GPL(xnvfile_init_link);
+
+void xnvfile_destroy(struct xnvfile *vfile)
+{
+       struct proc_dir_entry *ppde;
+
+       ppde = vfile->parent ? vfile->parent->entry.pde : rthal_proc_root;
+       remove_proc_entry(vfile->pde->name, ppde);
+}
+EXPORT_SYMBOL_GPL(xnvfile_destroy);
+
+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 &&
+           __xn_safe_copy_from_user(data, input->u_buf, nbytes))
+               return -EFAULT;
+
+       return nbytes;
+}
+EXPORT_SYMBOL_GPL(xnvfile_get_blob);
+
+void __vfile_hostlock_get(struct xnvfile *vfile)
+{
+       struct xnvfile_hostlock_class *lc;
+
+       lc = container_of(vfile->lockops, struct xnvfile_hostlock_class, ops);
+       down(&lc->sem);
+}
+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);
+       up(&lc->sem);
+}
+EXPORT_SYMBOL_GPL(__vfile_hostlock_put);
+
+static void __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);
+}
+
+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,
+       },
+};


_______________________________________________
Xenomai-git mailing list
Xenomai-git@gna.org
https://mail.gna.org/listinfo/xenomai-git

Reply via email to