datapath: Add 32-bit compatibility ioctls.

When a 32-bit userspace program runs on a 64-bit kernel, data structures
that contain members whose sizes or alignments change from 32- to 64-bit
must be translated when they are passed to ioctls.  This commit adds such
support for openvswitch_mod.

We should really reconsider some parts of the Open vSwitch ioctl interface
to avoid needing as much translation as we do.

Lightly tested with 32-bit userspace on sparc64.

diff --git a/datapath/Modules.mk b/datapath/Modules.mk
index b2032103683be7e23f1cfbb6bb000e66398b5011..ab9ae29924f029b39c93546519b518e9981cf46f 100644 (file)
--- a/datapath/Modules.mk
+++ b/datapath/Modules.mk
@@ -28,6 +28,7 @@ openvswitch_headers = \
        datapath.h \
        dp_sysfs.h \
        flow.h \
+       odp-compat.h \
        table.h \
        vport.h \
        vport-internal_dev.h \

diff --git a/datapath/datapath.c b/datapath/datapath.c
index 04b19894dc4ee303ae9c9df11571314cb46c7d5d..837f567caf929a945511199c9af467c0295a3fb0 100644 (file)
--- a/datapath/datapath.c
+++ b/datapath/datapath.c
@@ -40,11 +40,13 @@
 #include <linux/workqueue.h>
 #include <linux/dmi.h>
 #include <net/inet_ecn.h>
+#include <linux/compat.h>
 
 #include "openvswitch/datapath-protocol.h"
 #include "datapath.h"
 #include "actions.h"
 #include "flow.h"
+#include "odp-compat.h"
 #include "table.h"
 #include "vport-internal_dev.h"
 
@@ -1751,6 +1753,311 @@ static int dp_has_packet_of_interest(struct datapath *dp, int listeners)
        return 0;
 }
 
+#ifdef CONFIG_COMPAT
+static int compat_list_ports(struct datapath *dp, struct compat_odp_portvec __user *upv)
+{
+       struct compat_odp_portvec pv;
+       int retval;
+
+       if (copy_from_user(&pv, upv, sizeof pv))
+               return -EFAULT;
+
+       retval = do_list_ports(dp, compat_ptr(pv.ports), pv.n_ports);
+       if (retval < 0)
+               return retval;
+
+       return put_user(retval, &upv->n_ports);
+}
+
+static int compat_set_port_group(struct datapath *dp, const struct compat_odp_port_group __user *upg)
+{
+       struct compat_odp_port_group pg;
+
+       if (copy_from_user(&pg, upg, sizeof pg))
+               return -EFAULT;
+
+       return do_set_port_group(dp, compat_ptr(pg.ports), pg.n_ports, pg.group);
+}
+
+static int compat_get_port_group(struct datapath *dp, struct compat_odp_port_group __user *upg)
+{
+       struct compat_odp_port_group pg;
+
+       if (copy_from_user(&pg, upg, sizeof pg))
+               return -EFAULT;
+
+       return do_get_port_group(dp, compat_ptr(pg.ports), pg.n_ports,
+                                pg.group, &pg.n_ports);
+}
+
+static int compat_get_flow(struct odp_flow *flow, const struct compat_odp_flow __user *compat)
+{
+       compat_uptr_t actions;
+
+       if (!access_ok(VERIFY_READ, compat, sizeof(struct compat_odp_flow)) ||
+           __copy_from_user(&flow->stats, &compat->stats, sizeof(struct odp_flow_stats)) ||
+           __copy_from_user(&flow->key, &compat->key, sizeof(struct odp_flow_key)) ||
+           __get_user(actions, &compat->actions) ||
+           __get_user(flow->n_actions, &compat->n_actions) ||
+           __get_user(flow->flags, &compat->flags))
+               return -EFAULT;
+
+       flow->actions = compat_ptr(actions);
+       return 0;
+}
+
+static int compat_put_flow(struct datapath *dp, struct compat_odp_flow_put __user *ufp)
+{
+       struct odp_flow_stats stats;
+       struct odp_flow_put fp;
+       int error;
+
+       if (compat_get_flow(&fp.flow, &ufp->flow) ||
+           get_user(fp.flags, &ufp->flags))
+               return -EFAULT;
+
+       error = do_put_flow(dp, &fp, &stats);
+       if (error)
+               return error;
+
+       if (copy_to_user(&ufp->flow.stats, &stats,
+                        sizeof(struct odp_flow_stats)))
+               return -EFAULT;
+
+       return 0;
+}
+
+static int compat_answer_query(struct sw_flow *flow, u32 query_flags,
+                              struct compat_odp_flow __user *ufp)
+{
+       compat_uptr_t actions;
+
+       if (get_user(actions, &ufp->actions))
+               return -EFAULT;
+
+       return do_answer_query(flow, query_flags, &ufp->stats,
+                              compat_ptr(actions), &ufp->n_actions);
+}
+
+static int compat_del_flow(struct datapath *dp, struct compat_odp_flow __user *ufp)
+{
+       struct sw_flow *flow;
+       struct odp_flow uf;
+       int error;
+
+       if (compat_get_flow(&uf, ufp))
+               return -EFAULT;
+
+       flow = do_del_flow(dp, &uf.key);
+       if (IS_ERR(flow))
+               return PTR_ERR(flow);
+
+       error = compat_answer_query(flow, 0, ufp);
+       flow_deferred_free(flow);
+       return error;
+}
+
+static int compat_query_flows(struct datapath *dp, struct compat_odp_flow *flows, u32 n_flows)
+{
+       struct tbl *table = rcu_dereference(dp->table);
+       u32 i;
+
+       for (i = 0; i < n_flows; i++) {
+               struct compat_odp_flow __user *ufp = &flows[i];
+               struct odp_flow uf;
+               struct tbl_node *flow_node;
+               int error;
+
+               if (compat_get_flow(&uf, ufp))
+                       return -EFAULT;
+               memset(uf.key.reserved, 0, sizeof uf.key.reserved);
+
+               flow_node = tbl_lookup(table, &uf.key, flow_hash(&uf.key), flow_cmp);
+               if (!flow_node)
+                       error = put_user(ENOENT, &ufp->stats.error);
+               else
+                       error = compat_answer_query(flow_cast(flow_node), uf.flags, ufp);
+               if (error)
+                       return -EFAULT;
+       }
+       return n_flows;
+}
+
+struct compat_list_flows_cbdata {
+       struct compat_odp_flow __user *uflows;
+       u32 n_flows;
+       u32 listed_flows;
+};
+
+static int compat_list_flow(struct tbl_node *node, void *cbdata_)
+{
+       struct sw_flow *flow = flow_cast(node);
+       struct compat_list_flows_cbdata *cbdata = cbdata_;
+       struct compat_odp_flow __user *ufp = &cbdata->uflows[cbdata->listed_flows++];
+       int error;
+
+       if (copy_to_user(&ufp->key, &flow->key, sizeof flow->key))
+               return -EFAULT;
+       error = compat_answer_query(flow, 0, ufp);
+       if (error)
+               return error;
+
+       if (cbdata->listed_flows >= cbdata->n_flows)
+               return cbdata->listed_flows;
+       return 0;
+}
+
+static int compat_list_flows(struct datapath *dp, struct compat_odp_flow *flows, u32 n_flows)
+{
+       struct compat_list_flows_cbdata cbdata;
+       int error;
+
+       if (!n_flows)
+               return 0;
+
+       cbdata.uflows = flows;
+       cbdata.n_flows = n_flows;
+       cbdata.listed_flows = 0;
+       error = tbl_foreach(rcu_dereference(dp->table), compat_list_flow, &cbdata);
+       return error ? error : cbdata.listed_flows;
+}
+
+static int compat_flowvec_ioctl(struct datapath *dp, unsigned long argp,
+                               int (*function)(struct datapath *,
+                                               struct compat_odp_flow *,
+                                               u32 n_flows))
+{
+       struct compat_odp_flowvec __user *uflowvec;
+       struct compat_odp_flow __user *flows;
+       struct compat_odp_flowvec flowvec;
+       int retval;
+
+       uflowvec = compat_ptr(argp);
+       if (!access_ok(VERIFY_WRITE, uflowvec, sizeof *uflowvec) ||
+           copy_from_user(&flowvec, uflowvec, sizeof flowvec))
+               return -EFAULT;
+
+       if (flowvec.n_flows > INT_MAX / sizeof(struct compat_odp_flow))
+               return -EINVAL;
+
+       flows = compat_ptr(flowvec.flows);
+       if (!access_ok(VERIFY_WRITE, flows,
+                      flowvec.n_flows * sizeof(struct compat_odp_flow)))
+               return -EFAULT;
+
+       retval = function(dp, flows, flowvec.n_flows);
+       return (retval < 0 ? retval
+               : retval == flowvec.n_flows ? 0
+               : put_user(retval, &uflowvec->n_flows));
+}
+
+static int compat_execute(struct datapath *dp, const struct compat_odp_execute __user *uexecute)
+{
+       struct odp_execute execute;
+       compat_uptr_t actions;
+       compat_uptr_t data;
+
+       if (!access_ok(VERIFY_READ, uexecute, sizeof(struct compat_odp_execute)) ||
+           __get_user(execute.in_port, &uexecute->in_port) ||
+           __get_user(actions, &uexecute->actions) ||
+           __get_user(execute.n_actions, &uexecute->n_actions) ||
+           __get_user(data, &uexecute->data) ||
+           __get_user(execute.length, &uexecute->length))
+               return -EFAULT;
+
+       execute.actions = compat_ptr(actions);
+       execute.data = compat_ptr(data);
+
+       return do_execute(dp, &execute);
+}
+
+static long openvswitch_compat_ioctl(struct file *f, unsigned int cmd, unsigned long argp)
+{
+       int dp_idx = iminor(f->f_dentry->d_inode);
+       struct datapath *dp;
+       int err;
+
+       switch (cmd) {
+       case ODP_DP_DESTROY:
+       case ODP_FLOW_FLUSH:
+               /* Ioctls that don't need any translation at all. */
+               return openvswitch_ioctl(f, cmd, argp);
+
+       case ODP_DP_CREATE:
+       case ODP_PORT_ATTACH:
+       case ODP_PORT_DETACH:
+       case ODP_VPORT_DEL:
+       case ODP_VPORT_MTU_SET:
+       case ODP_VPORT_MTU_GET:
+       case ODP_VPORT_ETHER_SET:
+       case ODP_VPORT_ETHER_GET:
+       case ODP_VPORT_STATS_GET:
+       case ODP_DP_STATS:
+       case ODP_GET_DROP_FRAGS:
+       case ODP_SET_DROP_FRAGS:
+       case ODP_SET_LISTEN_MASK:
+       case ODP_GET_LISTEN_MASK:
+       case ODP_SET_SFLOW_PROBABILITY:
+       case ODP_GET_SFLOW_PROBABILITY:
+       case ODP_PORT_QUERY:
+               /* Ioctls that just need their pointer argument extended. */
+               return openvswitch_ioctl(f, cmd, (unsigned long)compat_ptr(argp));
+
+       case ODP_VPORT_ADD32:
+               return compat_vport_add(compat_ptr(argp));
+
+       case ODP_VPORT_MOD32:
+               return compat_vport_mod(compat_ptr(argp));
+       }
+
+       dp = get_dp_locked(dp_idx);
+       err = -ENODEV;
+       if (!dp)
+               goto exit;
+
+       switch (cmd) {
+       case ODP_PORT_LIST32:
+               err = compat_list_ports(dp, compat_ptr(argp));
+               break;
+
+       case ODP_PORT_GROUP_SET32:
+               err = compat_set_port_group(dp, compat_ptr(argp));
+               break;
+
+       case ODP_PORT_GROUP_GET32:
+               err = compat_get_port_group(dp, compat_ptr(argp));
+               break;
+
+       case ODP_FLOW_PUT32:
+               err = compat_put_flow(dp, compat_ptr(argp));
+               break;
+
+       case ODP_FLOW_DEL32:
+               err = compat_del_flow(dp, compat_ptr(argp));
+               break;
+
+       case ODP_FLOW_GET32:
+               err = compat_flowvec_ioctl(dp, argp, compat_query_flows);
+               break;
+
+       case ODP_FLOW_LIST32:
+               err = compat_flowvec_ioctl(dp, argp, compat_list_flows);
+               break;
+
+       case ODP_EXECUTE32:
+               err = compat_execute(dp, compat_ptr(argp));
+               break;
+
+       default:
+               err = -ENOIOCTLCMD;
+               break;
+       }
+       mutex_unlock(&dp->mutex);
+exit:
+       return err;
+}
+#endif
+
 ssize_t openvswitch_read(struct file *f, char __user *buf, size_t nbytes,
                      loff_t *ppos)
 {
@@ -1830,6 +2137,9 @@ struct file_operations openvswitch_fops = {
        .read  = openvswitch_read,
        .poll  = openvswitch_poll,
        .unlocked_ioctl = openvswitch_ioctl,
+#ifdef CONFIG_COMPAT
+       .compat_ioctl = openvswitch_compat_ioctl,
+#endif
        /* XXX .fasync = openvswitch_fasync, */
 };
 

diff --git a/datapath/odp-compat.h b/datapath/odp-compat.h
new file mode 100644 (file)
index 0000000..3d7b803
--- /dev/null
+++ b/datapath/odp-compat.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2010 Nicira Networks.
+ * Distributed under the terms of the GNU GPL version 2.
+ *
+ * Significant portions of this file may be copied from parts of the Linux
+ * kernel, by Linus Torvalds and others.
+ */
+
+#ifndef ODP_COMPAT_H
+#define ODP_COMPAT_H 1
+
+/* 32-bit ioctl compatibility definitions for datapath protocol. */
+
+#ifdef CONFIG_COMPAT
+#include "openvswitch/datapath-protocol.h"
+#include <linux/compat.h>
+
+#define ODP_PORT_LIST32                _IOWR('O', 10, struct compat_odp_portvec)
+#define ODP_PORT_GROUP_SET32   _IOR('O', 11, struct compat_odp_port_group)
+#define ODP_PORT_GROUP_GET32   _IOWR('O', 12, struct compat_odp_port_group)
+#define ODP_FLOW_GET32         _IOWR('O', 13, struct compat_odp_flow)
+#define ODP_FLOW_PUT32         _IOWR('O', 14, struct compat_odp_flow)
+#define ODP_FLOW_LIST32                _IOWR('O', 15, struct compat_odp_flowvec)
+#define ODP_FLOW_DEL32         _IOWR('O', 17, struct compat_odp_flow)
+#define ODP_EXECUTE32          _IOR('O', 18, struct compat_odp_execute)
+#define ODP_FLOW_DEL32         _IOWR('O', 17, struct compat_odp_flow)
+#define ODP_VPORT_ADD32                _IOR('O', 21, struct compat_odp_vport_add)
+#define ODP_VPORT_MOD32                _IOR('O', 22, struct compat_odp_vport_mod)
+
+struct compat_odp_portvec {
+       compat_uptr_t ports;
+       u32 n_ports;
+};
+
+struct compat_odp_port_group {
+       compat_uptr_t ports;
+       u16 n_ports;            /* Number of ports. */
+       u16 group;              /* Group number. */
+};
+
+struct compat_odp_flow {
+       struct odp_flow_stats stats;
+       struct odp_flow_key key;
+       compat_uptr_t actions;
+       u32 n_actions;
+       u32 flags;
+};
+
+struct compat_odp_flow_put {
+       struct compat_odp_flow flow;
+       u32 flags;
+};
+
+struct compat_odp_flowvec {
+       compat_uptr_t flows;
+       u32 n_flows;
+};
+
+struct compat_odp_execute {
+       u16 in_port;
+       u16 reserved1;
+       u32 reserved2;
+
+       compat_uptr_t actions;
+       u32 n_actions;
+
+       compat_uptr_t data;
+       u32 length;
+};
+
+struct compat_odp_vport_add {
+       char port_type[VPORT_TYPE_SIZE];
+       char devname[16];            /* IFNAMSIZ */
+       compat_uptr_t config;
+};
+
+struct compat_odp_vport_mod {
+       char devname[16];            /* IFNAMSIZ */
+       compat_uptr_t config;
+};
+#endif /* CONFIG_COMPAT */
+
+#endif /* odp-compat.h */

diff --git a/datapath/vport.c b/datapath/vport.c
index 5656672c465fa37937680809ff23fcf70785a189..6b7381e9f1f6b1d5351ebd983e8b19fdd131456c 100644 (file)
--- a/datapath/vport.c
+++ b/datapath/vport.c
@@ -14,6 +14,7 @@
 #include <linux/mutex.h>
 #include <linux/percpu.h>
 #include <linux/rtnetlink.h>
+#include <linux/compat.h>
 
 #include "vport.h"
 
@@ -228,6 +229,24 @@ vport_add(const struct odp_vport_add __user *uvport_config)
        return do_vport_add(&vport_config);
 }
 
+#ifdef CONFIG_COMPAT
+int
+compat_vport_add(struct compat_odp_vport_add *ucompat)
+{
+       struct compat_odp_vport_add compat;
+       struct odp_vport_add vport_config;
+
+       if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_add)))
+               return -EFAULT;
+
+       memcpy(vport_config.port_type, compat.port_type, VPORT_TYPE_SIZE);
+       memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
+       vport_config.config = compat_ptr(compat.config);
+
+       return do_vport_add(&vport_config);
+}
+#endif
+
 /**
  *     vport_mod - modify existing vport device (for userspace callers)
  *
@@ -273,6 +292,23 @@ vport_mod(const struct odp_vport_mod __user *uvport_config)
        return do_vport_mod(&vport_config);
 }
 
+#ifdef CONFIG_COMPAT
+int
+compat_vport_mod(struct compat_odp_vport_mod *ucompat)
+{
+       struct compat_odp_vport_mod compat;
+       struct odp_vport_mod vport_config;
+
+       if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_mod)))
+               return -EFAULT;
+
+       memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
+       vport_config.config = compat_ptr(compat.config);
+
+       return do_vport_mod(&vport_config);
+}
+#endif
+
 /**
  *     vport_del - delete existing vport device (for userspace callers)
  *

diff --git a/datapath/vport.h b/datapath/vport.h
index 7b71226c56a26cc9888942e3575abbd4a632b80c..a26f232a76d0923ca2769ada3c70f849b5a98b30 100644 (file)
--- a/datapath/vport.h
+++ b/datapath/vport.h
@@ -15,6 +15,7 @@
 
 #include "datapath.h"
 #include "openvswitch/datapath-protocol.h"
+#include "odp-compat.h"
 
 struct vport;
 struct dp_port;
@@ -31,6 +32,11 @@ int vport_add(const struct odp_vport_add __user *);
 int vport_mod(const struct odp_vport_mod __user *);
 int vport_del(const char __user *udevname);
 
+#ifdef CONFIG_COMPAT
+int compat_vport_add(struct compat_odp_vport_add __user *);
+int compat_vport_mod(struct compat_odp_vport_mod __user *);
+#endif
+
 int vport_stats_get(struct odp_vport_stats_req __user *);
 int vport_ether_get(struct odp_vport_ether __user *);
 int vport_ether_set(struct odp_vport_ether __user *);

diff --git a/include/openvswitch/datapath-protocol.h b/include/openvswitch/datapath-protocol.h
index 0e8d5c9e0054919d665c1309a65a442b0b5f03f8..826dc27f70591812ad58273e1620b2d5e419d727 100644 (file)
--- a/include/openvswitch/datapath-protocol.h
+++ b/include/openvswitch/datapath-protocol.h
@@ -37,7 +37,10 @@
  * ----------------------------------------------------------------------
  */
 
-/* Protocol between userspace and kernel datapath. */
+/* Protocol between userspace and kernel datapath.
+ *
+ * Be sure to update datapath/odp-compat.h if you change any of the structures
+ * in here. */
 
 #ifndef OPENVSWITCH_DATAPATH_PROTOCOL_H
 #define OPENVSWITCH_DATAPATH_PROTOCOL_H 1