/***
|
*
|
* rtcfg/rtcfg_proc.c
|
*
|
* Real-Time Configuration Distribution Protocol
|
*
|
* Copyright (C) 2004 Jan Kiszka <jan.kiszka@web.de>
|
*
|
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
*
|
*/
|
|
#include <rtdev.h>
|
#include <rtnet_internal.h>
|
#include <rtnet_port.h>
|
#include <rtcfg/rtcfg_conn_event.h>
|
#include <rtcfg/rtcfg_event.h>
|
#include <rtcfg/rtcfg_frame.h>
|
|
#ifdef CONFIG_XENO_OPT_VFILE
|
DEFINE_MUTEX(nrt_proc_lock);
|
static struct xnvfile_directory rtcfg_proc_root;
|
|
static int rtnet_rtcfg_proc_lock_get(struct xnvfile *vfile)
|
{
|
return mutex_lock_interruptible(&nrt_proc_lock);
|
}
|
|
static void rtnet_rtcfg_proc_lock_put(struct xnvfile *vfile)
|
{
|
return mutex_unlock(&nrt_proc_lock);
|
}
|
|
static struct xnvfile_lock_ops rtnet_rtcfg_proc_lock_ops = {
|
.get = rtnet_rtcfg_proc_lock_get,
|
.put = rtnet_rtcfg_proc_lock_put,
|
};
|
|
int rtnet_rtcfg_dev_state_show(struct xnvfile_regular_iterator *it, void *data)
|
{
|
struct rtcfg_device *rtcfg_dev = xnvfile_priv(it->vfile);
|
const char *state_name[] = { "OFF",
|
"SERVER_RUNNING",
|
"CLIENT_0",
|
"CLIENT_1",
|
"CLIENT_ANNOUNCED",
|
"CLIENT_ALL_KNOWN",
|
"CLIENT_ALL_FRAMES",
|
"CLIENT_2",
|
"CLIENT_READY" };
|
|
xnvfile_printf(it,
|
"state:\t\t\t%d (%s)\n"
|
"flags:\t\t\t%08lX\n"
|
"other stations:\t\t%d\n"
|
"stations found:\t\t%d\n"
|
"stations ready:\t\t%d\n",
|
rtcfg_dev->state, state_name[rtcfg_dev->state],
|
rtcfg_dev->flags, rtcfg_dev->other_stations,
|
rtcfg_dev->stations_found, rtcfg_dev->stations_ready);
|
|
if (rtcfg_dev->state == RTCFG_MAIN_SERVER_RUNNING) {
|
xnvfile_printf(it,
|
"configured clients:\t%d\n"
|
"burstrate:\t\t%d\n"
|
"heartbeat period:\t%d ms\n",
|
rtcfg_dev->spec.srv.clients_configured,
|
rtcfg_dev->burstrate,
|
rtcfg_dev->spec.srv.heartbeat);
|
} else if (rtcfg_dev->state != RTCFG_MAIN_OFF) {
|
xnvfile_printf(
|
it,
|
"address type:\t\t%d\n"
|
"server address:\t\t%02X:%02X:%02X:%02X:%02X:%02X\n"
|
"stage 2 config:\t\t%d/%d\n",
|
rtcfg_dev->spec.clt.addr_type,
|
rtcfg_dev->spec.clt.srv_mac_addr[0],
|
rtcfg_dev->spec.clt.srv_mac_addr[1],
|
rtcfg_dev->spec.clt.srv_mac_addr[2],
|
rtcfg_dev->spec.clt.srv_mac_addr[3],
|
rtcfg_dev->spec.clt.srv_mac_addr[4],
|
rtcfg_dev->spec.clt.srv_mac_addr[5],
|
rtcfg_dev->spec.clt.cfg_offs,
|
rtcfg_dev->spec.clt.cfg_len);
|
}
|
|
return 0;
|
}
|
|
static struct xnvfile_regular_ops rtnet_rtcfg_dev_state_vfile_ops = {
|
.show = rtnet_rtcfg_dev_state_show,
|
};
|
|
int rtnet_rtcfg_dev_stations_show(struct xnvfile_regular_iterator *it, void *d)
|
{
|
struct rtcfg_device *rtcfg_dev = xnvfile_priv(it->vfile);
|
struct rtcfg_connection *conn;
|
struct rtcfg_station *station;
|
int i;
|
|
if (rtcfg_dev->state == RTCFG_MAIN_SERVER_RUNNING) {
|
list_for_each_entry (conn, &rtcfg_dev->spec.srv.conn_list,
|
entry) {
|
if ((conn->state != RTCFG_CONN_SEARCHING) &&
|
(conn->state != RTCFG_CONN_DEAD))
|
xnvfile_printf(
|
it,
|
"%02X:%02X:%02X:%02X:%02X:%02X\t%02X\n",
|
conn->mac_addr[0], conn->mac_addr[1],
|
conn->mac_addr[2], conn->mac_addr[3],
|
conn->mac_addr[4], conn->mac_addr[5],
|
conn->flags);
|
}
|
} else if (rtcfg_dev->spec.clt.station_addr_list) {
|
for (i = 0; i < rtcfg_dev->stations_found; i++) {
|
station = &rtcfg_dev->spec.clt.station_addr_list[i];
|
|
xnvfile_printf(
|
it, "%02X:%02X:%02X:%02X:%02X:%02X\t%02X\n",
|
station->mac_addr[0], station->mac_addr[1],
|
station->mac_addr[2], station->mac_addr[3],
|
station->mac_addr[4], station->mac_addr[5],
|
station->flags);
|
}
|
}
|
|
return 0;
|
}
|
|
static struct xnvfile_regular_ops rtnet_rtcfg_dev_stations_vfile_ops = {
|
.show = rtnet_rtcfg_dev_stations_show,
|
};
|
|
int rtnet_rtcfg_dev_conn_state_show(struct xnvfile_regular_iterator *it,
|
void *d)
|
{
|
struct rtcfg_connection *conn = xnvfile_priv(it->vfile);
|
char *state_name[] = { "SEARCHING", "STAGE_1", "STAGE_2", "READY",
|
"DEAD" };
|
|
xnvfile_printf(it,
|
"state:\t\t\t%d (%s)\n"
|
"flags:\t\t\t%02X\n"
|
"stage 1 size:\t\t%zd\n"
|
"stage 2 filename:\t%s\n"
|
"stage 2 size:\t\t%zd\n"
|
"stage 2 offset:\t\t%d\n"
|
"burstrate:\t\t%d\n"
|
"mac address:\t\t%02X:%02X:%02X:%02X:%02X:%02X\n",
|
conn->state, state_name[conn->state], conn->flags,
|
conn->stage1_size,
|
(conn->stage2_file) ? conn->stage2_file->name : "-",
|
(conn->stage2_file) ? conn->stage2_file->size : 0,
|
conn->cfg_offs, conn->burstrate, conn->mac_addr[0],
|
conn->mac_addr[1], conn->mac_addr[2], conn->mac_addr[3],
|
conn->mac_addr[4], conn->mac_addr[5]);
|
|
#if IS_ENABLED(CONFIG_XENO_DRIVERS_NET_RTIPV4)
|
if ((conn->addr_type & RTCFG_ADDR_MASK) == RTCFG_ADDR_IP)
|
xnvfile_printf(it, "ip:\t\t\t%u.%u.%u.%u\n",
|
NIPQUAD(conn->addr.ip_addr));
|
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4 */
|
|
return 0;
|
}
|
|
static struct xnvfile_regular_ops rtnet_rtcfg_dev_conn_state_vfile_ops = {
|
.show = rtnet_rtcfg_dev_conn_state_show,
|
};
|
|
void rtcfg_update_conn_proc_entries(int ifindex)
|
{
|
struct rtcfg_device *dev = &device[ifindex];
|
struct rtcfg_connection *conn;
|
char name_buf[64];
|
|
if (dev->state != RTCFG_MAIN_SERVER_RUNNING)
|
return;
|
|
list_for_each_entry (conn, &dev->spec.srv.conn_list, entry) {
|
switch (conn->addr_type & RTCFG_ADDR_MASK) {
|
#if IS_ENABLED(CONFIG_XENO_DRIVERS_NET_RTIPV4)
|
case RTCFG_ADDR_IP:
|
snprintf(name_buf, 64, "CLIENT_%u.%u.%u.%u",
|
NIPQUAD(conn->addr.ip_addr));
|
break;
|
#endif /* CONFIG_XENO_DRIVERS_NET_RTIPV4 */
|
|
default: /* RTCFG_ADDR_MAC */
|
snprintf(name_buf, 64,
|
"CLIENT_%02X%02X%02X%02X%02X%02X",
|
conn->mac_addr[0], conn->mac_addr[1],
|
conn->mac_addr[2], conn->mac_addr[3],
|
conn->mac_addr[4], conn->mac_addr[5]);
|
break;
|
}
|
memset(&conn->proc_entry, '\0', sizeof(conn->proc_entry));
|
conn->proc_entry.entry.lockops = &rtnet_rtcfg_proc_lock_ops;
|
conn->proc_entry.ops = &rtnet_rtcfg_dev_conn_state_vfile_ops;
|
xnvfile_priv(&conn->proc_entry) = conn;
|
|
xnvfile_init_regular(name_buf, &conn->proc_entry,
|
&dev->proc_entry);
|
}
|
}
|
|
void rtcfg_remove_conn_proc_entries(int ifindex)
|
{
|
struct rtcfg_device *dev = &device[ifindex];
|
struct rtcfg_connection *conn;
|
|
if (dev->state != RTCFG_MAIN_SERVER_RUNNING)
|
return;
|
|
list_for_each_entry (conn, &dev->spec.srv.conn_list, entry)
|
xnvfile_destroy_regular(&conn->proc_entry);
|
}
|
|
void rtcfg_new_rtdev(struct rtnet_device *rtdev)
|
{
|
struct rtcfg_device *dev = &device[rtdev->ifindex];
|
int err;
|
|
mutex_lock(&nrt_proc_lock);
|
|
memset(&dev->proc_entry, '\0', sizeof(dev->proc_entry));
|
err = xnvfile_init_dir(rtdev->name, &dev->proc_entry, &rtcfg_proc_root);
|
if (err < 0)
|
goto error1;
|
|
memset(&dev->proc_state_vfile, '\0', sizeof(dev->proc_state_vfile));
|
dev->proc_state_vfile.entry.lockops = &rtnet_rtcfg_proc_lock_ops;
|
dev->proc_state_vfile.ops = &rtnet_rtcfg_dev_state_vfile_ops;
|
xnvfile_priv(&dev->proc_state_vfile) = dev;
|
|
err = xnvfile_init_regular("state", &dev->proc_state_vfile,
|
&dev->proc_entry);
|
if (err < 0)
|
goto error2;
|
|
memset(&dev->proc_stations_vfile, '\0',
|
sizeof(dev->proc_stations_vfile));
|
dev->proc_stations_vfile.entry.lockops = &rtnet_rtcfg_proc_lock_ops;
|
dev->proc_stations_vfile.ops = &rtnet_rtcfg_dev_stations_vfile_ops;
|
xnvfile_priv(&dev->proc_stations_vfile) = dev;
|
|
err = xnvfile_init_regular("stations_list", &dev->proc_stations_vfile,
|
&dev->proc_entry);
|
if (err < 0)
|
goto error3;
|
|
mutex_unlock(&nrt_proc_lock);
|
|
return;
|
|
error3:
|
xnvfile_destroy_regular(&dev->proc_state_vfile);
|
error2:
|
xnvfile_destroy_dir(&dev->proc_entry);
|
error1:
|
dev->proc_entry.entry.pde = NULL;
|
mutex_unlock(&nrt_proc_lock);
|
}
|
|
void rtcfg_remove_rtdev(struct rtnet_device *rtdev)
|
{
|
struct rtcfg_device *dev = &device[rtdev->ifindex];
|
|
// To-Do: issue down command
|
|
mutex_lock(&nrt_proc_lock);
|
|
if (dev->proc_entry.entry.pde) {
|
rtcfg_remove_conn_proc_entries(rtdev->ifindex);
|
|
xnvfile_destroy_regular(&dev->proc_stations_vfile);
|
xnvfile_destroy_regular(&dev->proc_state_vfile);
|
xnvfile_destroy_dir(&dev->proc_entry);
|
dev->proc_entry.entry.pde = NULL;
|
}
|
|
mutex_unlock(&nrt_proc_lock);
|
}
|
|
static struct rtdev_event_hook rtdev_hook = { .register_device =
|
rtcfg_new_rtdev,
|
.unregister_device =
|
rtcfg_remove_rtdev,
|
.ifup = NULL,
|
.ifdown = NULL };
|
|
int rtcfg_init_proc(void)
|
{
|
struct rtnet_device *rtdev;
|
int i, err;
|
|
err = xnvfile_init_dir("rtcfg", &rtcfg_proc_root, &rtnet_proc_root);
|
if (err < 0)
|
goto err1;
|
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
rtdev = rtdev_get_by_index(i);
|
if (rtdev) {
|
rtcfg_new_rtdev(rtdev);
|
rtdev_dereference(rtdev);
|
}
|
}
|
|
rtdev_add_event_hook(&rtdev_hook);
|
return 0;
|
|
err1:
|
printk("RTcfg: unable to initialise /proc entries\n");
|
return err;
|
}
|
|
void rtcfg_cleanup_proc(void)
|
{
|
struct rtnet_device *rtdev;
|
int i;
|
|
rtdev_del_event_hook(&rtdev_hook);
|
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
rtdev = rtdev_get_by_index(i);
|
if (rtdev) {
|
rtcfg_remove_rtdev(rtdev);
|
rtdev_dereference(rtdev);
|
}
|
}
|
|
xnvfile_destroy_dir(&rtcfg_proc_root);
|
}
|
|
#endif /* CONFIG_XENO_OPT_VFILE */
|
