#include <linux/rculist.h>
#include <linux/dmi.h>
#include <net/inet_ecn.h>
+#include <net/genetlink.h>
#include <linux/compat.h>
#include "openvswitch/datapath-protocol.h"
OVS_CB(skb)->vport = p;
if (!OVS_CB(skb)->flow) {
- struct odp_flow_key key;
+ struct sw_flow_key key;
struct tbl_node *flow_node;
bool is_frag;
flow_node = tbl_lookup(rcu_dereference(dp->table), &key,
flow_hash(&key), flow_cmp);
if (unlikely(!flow_node)) {
- dp_output_control(dp, skb, _ODPL_MISS_NR,
- (__force u64)OVS_CB(skb)->tun_id);
+ struct dp_upcall_info upcall;
+
+ upcall.type = _ODPL_MISS_NR;
+ upcall.key = &key;
+ upcall.userdata = 0;
+ upcall.sample_pool = 0;
+ upcall.actions = NULL;
+ upcall.actions_len = 0;
+ dp_upcall(dp, skb, &upcall);
stats_counter_off = offsetof(struct dp_stats_percpu, n_missed);
goto out;
}
local_bh_enable();
}
+static void copy_and_csum_skb(struct sk_buff *skb, void *to)
+{
+ u16 csum_start, csum_offset;
+ __wsum csum;
+
+ get_skb_csum_pointers(skb, &csum_start, &csum_offset);
+ csum_start -= skb_headroom(skb);
+ BUG_ON(csum_start >= skb_headlen(skb));
+
+ skb_copy_bits(skb, 0, to, csum_start);
+
+ csum = skb_copy_and_csum_bits(skb, csum_start, to + csum_start,
+ skb->len - csum_start, 0);
+ *(__sum16 *)(to + csum_start + csum_offset) = csum_fold(csum);
+}
+
/* Append each packet in 'skb' list to 'queue'. There will be only one packet
* unless we broke up a GSO packet. */
-static int queue_control_packets(struct sk_buff *skb, struct sk_buff_head *queue,
- int queue_no, u64 arg)
+static int queue_control_packets(struct datapath *dp, struct sk_buff *skb,
+ const struct dp_upcall_info *upcall_info)
{
struct sk_buff *nskb;
int port_no;
port_no = ODPP_LOCAL;
do {
- struct odp_msg *header;
+ struct odp_packet *upcall;
+ struct sk_buff *user_skb; /* to be queued to userspace */
+ struct nlattr *nla;
+ unsigned int len;
nskb = skb->next;
skb->next = NULL;
- err = skb_cow(skb, sizeof(*header));
- if (err)
+ len = sizeof(struct odp_packet);
+ len += nla_total_size(4); /* ODP_PACKET_ATTR_TYPE. */
+ len += nla_total_size(skb->len);
+ len += nla_total_size(FLOW_BUFSIZE);
+ if (upcall_info->userdata)
+ len += nla_total_size(8);
+ if (upcall_info->sample_pool)
+ len += nla_total_size(4);
+ if (upcall_info->actions_len)
+ len += nla_total_size(upcall_info->actions_len);
+
+ user_skb = alloc_skb(len, GFP_ATOMIC);
+ if (!user_skb)
goto err_kfree_skbs;
- header = (struct odp_msg*)__skb_push(skb, sizeof(*header));
- header->type = queue_no;
- header->length = skb->len;
- header->port = port_no;
- header->arg = arg;
- skb_queue_tail(queue, skb);
+ upcall = (struct odp_packet *)__skb_put(user_skb, sizeof(*upcall));
+ upcall->dp_idx = dp->dp_idx;
+
+ nla_put_u32(user_skb, ODP_PACKET_ATTR_TYPE, upcall_info->type);
+
+ nla = nla_nest_start(user_skb, ODP_PACKET_ATTR_KEY);
+ flow_to_nlattrs(upcall_info->key, user_skb);
+ nla_nest_end(user_skb, nla);
+ if (upcall_info->userdata)
+ nla_put_u64(user_skb, ODP_PACKET_ATTR_USERDATA, upcall_info->userdata);
+ if (upcall_info->sample_pool)
+ nla_put_u32(user_skb, ODP_PACKET_ATTR_SAMPLE_POOL, upcall_info->sample_pool);
+ if (upcall_info->actions_len) {
+ const struct nlattr *actions = upcall_info->actions;
+ u32 actions_len = upcall_info->actions_len;
+
+ nla = nla_nest_start(user_skb, ODP_PACKET_ATTR_ACTIONS);
+ memcpy(__skb_put(user_skb, actions_len), actions, actions_len);
+ nla_nest_end(user_skb, nla);
+ }
+
+ nla = __nla_reserve(user_skb, ODP_PACKET_ATTR_PACKET, skb->len);
+ if (skb->ip_summed == CHECKSUM_PARTIAL)
+ copy_and_csum_skb(skb, nla_data(nla));
+ else
+ skb_copy_bits(skb, 0, nla_data(nla), skb->len);
+
+ upcall->len = user_skb->len;
+ skb_queue_tail(&dp->queues[upcall_info->type], user_skb);
+
+ kfree_skb(skb);
skb = nskb;
} while (skb);
return 0;
return err;
}
-int dp_output_control(struct datapath *dp, struct sk_buff *skb, int queue_no,
- u64 arg)
+int dp_upcall(struct datapath *dp, struct sk_buff *skb, const struct dp_upcall_info *upcall_info)
{
struct dp_stats_percpu *stats;
struct sk_buff_head *queue;
int err;
WARN_ON_ONCE(skb_shared(skb));
- BUG_ON(queue_no != _ODPL_MISS_NR && queue_no != _ODPL_ACTION_NR && queue_no != _ODPL_SFLOW_NR);
- queue = &dp->queues[queue_no];
+ BUG_ON(upcall_info->type >= DP_N_QUEUES);
+
+ queue = &dp->queues[upcall_info->type];
err = -ENOBUFS;
if (skb_queue_len(queue) >= DP_MAX_QUEUE_LEN)
goto err_kfree_skb;
}
}
- err = queue_control_packets(skb, queue, queue_no, arg);
+ err = queue_control_packets(dp, skb, upcall_info);
wake_up_interruptible(&dp->waitqueue);
return err;
struct odp_flow_stats *stats)
{
struct tbl_node *flow_node;
+ struct sw_flow_key key;
struct sw_flow *flow;
struct tbl *table;
struct sw_flow_actions *acts = NULL;
int error;
u32 hash;
- hash = flow_hash(&uf->flow.key);
+ error = flow_copy_from_user(&key, (const struct nlattr __force __user *)uf->flow.key,
+ uf->flow.key_len);
+ if (error)
+ return error;
+
+ hash = flow_hash(&key);
table = get_table_protected(dp);
- flow_node = tbl_lookup(table, &uf->flow.key, hash, flow_cmp);
+ flow_node = tbl_lookup(table, &key, hash, flow_cmp);
if (!flow_node) {
/* No such flow. */
error = -ENOENT;
error = PTR_ERR(flow);
goto error;
}
- flow->key = uf->flow.key;
+ flow->key = key;
clear_stats(flow);
/* Obtain actions. */
&ufp->stats, actions, &ufp->actions_len);
}
-static struct sw_flow *do_del_flow(struct datapath *dp, struct odp_flow_key *key)
+static struct sw_flow *do_del_flow(struct datapath *dp, const struct nlattr __user *key, u32 key_len)
{
struct tbl *table = get_table_protected(dp);
struct tbl_node *flow_node;
+ struct sw_flow_key swkey;
int error;
- flow_node = tbl_lookup(table, key, flow_hash(key), flow_cmp);
+ error = flow_copy_from_user(&swkey, key, key_len);
+ if (error)
+ return ERR_PTR(error);
+
+ flow_node = tbl_lookup(table, &swkey, flow_hash(&swkey), flow_cmp);
if (!flow_node)
return ERR_PTR(-ENOENT);
if (copy_from_user(&uf, ufp, sizeof(uf)))
return -EFAULT;
- flow = do_del_flow(dp, &uf.key);
+ flow = do_del_flow(dp, (const struct nlattr __force __user *)uf.key, uf.key_len);
if (IS_ERR(flow))
return PTR_ERR(flow);
for (i = 0; i < flowvec->n_flows; i++) {
struct odp_flow __user *ufp = (struct odp_flow __user __force *)&flowvec->flows[i];
+ struct sw_flow_key key;
struct odp_flow uf;
struct tbl_node *flow_node;
int error;
if (copy_from_user(&uf, ufp, sizeof(uf)))
return -EFAULT;
- flow_node = tbl_lookup(table, &uf.key, flow_hash(&uf.key), flow_cmp);
+ error = flow_copy_from_user(&key, (const struct nlattr __force __user *)uf.key, uf.key_len);
+ if (error)
+ return error;
+
+ flow_node = tbl_lookup(table, &uf.key, flow_hash(&key), flow_cmp);
if (!flow_node)
error = put_user(ENOENT, &ufp->stats.error);
else
static int dump_flow(struct datapath *dp, struct odp_flow_dump __user *udumpp)
{
struct odp_flow __user *uflowp;
+ struct nlattr __user *ukey;
struct sw_flow *flow;
+ u32 key_len;
flow = do_dump_flow(dp, udumpp->state);
if (IS_ERR(flow))
if (!flow)
return put_user(ODPFF_EOF, &uflowp->flags);
- if (copy_to_user(&uflowp->key, &flow->key, sizeof(struct odp_flow_key)) ||
- put_user(0, &uflowp->flags))
+ if (put_user(0, &uflowp->flags) ||
+ get_user(ukey, (struct nlattr __user * __user*)&uflowp->key) ||
+ get_user(key_len, &uflowp->key_len))
+ return -EFAULT;
+
+ key_len = flow_copy_to_user(ukey, &flow->key, key_len);
+ if (key_len < 0)
+ return key_len;
+ if (put_user(key_len, &uflowp->key_len))
return -EFAULT;
+
return answer_query(dp, flow, 0, uflowp);
}
static int do_execute(struct datapath *dp, const struct odp_execute *execute)
{
- struct odp_flow_key key;
+ struct sw_flow_key key;
struct sk_buff *skb;
struct sw_flow_actions *actions;
struct ethhdr *eth;
}
}
-static int put_port(const struct vport *p, struct odp_port __user *uop)
+static void compose_odp_port(const struct vport *vport, struct odp_port *odp_port)
{
- struct odp_port op;
-
- memset(&op, 0, sizeof(op));
-
rcu_read_lock();
- strncpy(op.devname, vport_get_name(p), sizeof(op.devname));
- strncpy(op.type, vport_get_type(p), sizeof(op.type));
- vport_get_config(p, op.config);
+ strncpy(odp_port->devname, vport_get_name(vport), sizeof(odp_port->devname));
+ strncpy(odp_port->type, vport_get_type(vport), sizeof(odp_port->type));
+ vport_get_config(vport, odp_port->config);
+ odp_port->port = vport->port_no;
+ odp_port->dp_idx = vport->dp->dp_idx;
rcu_read_unlock();
-
- op.port = p->port_no;
-
- return copy_to_user(uop, &op, sizeof(op)) ? -EFAULT : 0;
}
-static int query_port(struct datapath *dp, struct odp_port __user *uport)
+static int query_port(int dp_idx, struct odp_port __user *uport)
{
struct odp_port port;
- struct vport *vport;
if (copy_from_user(&port, uport, sizeof(port)))
return -EFAULT;
if (port.devname[0]) {
+ struct vport *vport;
+
port.devname[IFNAMSIZ - 1] = '\0';
vport_lock();
vport = vport_locate(port.devname);
+ if (vport)
+ compose_odp_port(vport, &port);
vport_unlock();
if (!vport)
return -ENODEV;
- if (vport->dp != dp)
- return -ENOENT;
} else {
+ struct vport *vport;
+ struct datapath *dp;
+
if (port.port >= DP_MAX_PORTS)
return -EINVAL;
+ dp = get_dp_locked(dp_idx);
+ if (!dp)
+ return -ENODEV;
+
vport = get_vport_protected(dp, port.port);
+ if (vport)
+ compose_odp_port(vport, &port);
+ mutex_unlock(&dp->mutex);
+
if (!vport)
return -ENOENT;
}
- return put_port(vport, uport);
+ return copy_to_user(uport, &port, sizeof(struct odp_port));
}
-static int do_list_ports(struct datapath *dp, struct odp_port __user *uports,
- int n_ports)
+static int do_dump_port(struct datapath *dp, struct odp_vport_dump *dump)
{
- int idx = 0;
- if (n_ports) {
- struct vport *p;
-
- list_for_each_entry_rcu (p, &dp->port_list, node) {
- if (put_port(p, &uports[idx]))
- return -EFAULT;
- if (idx++ >= n_ports)
- break;
+ u32 port_no;
+
+ for (port_no = dump->port_no; port_no < DP_MAX_PORTS; port_no++) {
+ struct vport *vport = get_vport_protected(dp, port_no);
+ if (vport) {
+ struct odp_port odp_port;
+
+ compose_odp_port(vport, &odp_port);
+ return copy_to_user((struct odp_port __force __user*)dump->port, &odp_port, sizeof(struct odp_port));
}
}
- return idx;
+
+ return put_user('\0', (char __force __user*)&dump->port->devname[0]);
}
-static int list_ports(struct datapath *dp, struct odp_portvec __user *upv)
+static int dump_port(struct datapath *dp, struct odp_vport_dump __user *udump)
{
- struct odp_portvec pv;
- int retval;
+ struct odp_vport_dump dump;
- if (copy_from_user(&pv, upv, sizeof(pv)))
+ if (copy_from_user(&dump, udump, sizeof(dump)))
return -EFAULT;
- retval = do_list_ports(dp, (struct odp_port __user __force *)pv.ports,
- pv.n_ports);
- if (retval < 0)
- return retval;
-
- return put_user(retval, &upv->n_ports);
+ return do_dump_port(dp, &dump);
}
static int get_listen_mask(const struct file *f)
err = detach_port(dp_idx, port_no);
goto exit;
+ case ODP_VPORT_QUERY:
+ err = query_port(dp_idx, (struct odp_port __user *)argp);
+ goto exit;
+
case ODP_VPORT_MOD:
err = vport_user_mod((struct odp_port __user *)argp);
goto exit;
dp->sflow_probability = sflow_probability;
break;
- case ODP_VPORT_QUERY:
- err = query_port(dp, (struct odp_port __user *)argp);
- break;
-
- case ODP_VPORT_LIST:
- err = list_ports(dp, (struct odp_portvec __user *)argp);
+ case ODP_VPORT_DUMP:
+ err = dump_port(dp, (struct odp_vport_dump __user *)argp);
break;
case ODP_FLOW_FLUSH:
}
#ifdef CONFIG_COMPAT
-static int compat_list_ports(struct datapath *dp, struct compat_odp_portvec __user *upv)
+static int compat_dump_port(struct datapath *dp, struct compat_odp_vport_dump __user *compat)
{
- struct compat_odp_portvec pv;
- int retval;
+ struct odp_vport_dump dump;
+ compat_uptr_t port;
- if (copy_from_user(&pv, upv, sizeof(pv)))
+ if (!access_ok(VERIFY_READ, compat, sizeof(struct compat_odp_vport_dump)) ||
+ __get_user(port, &compat->port) ||
+ __get_user(dump.port_no, &compat->port_no))
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);
+ dump.port = (struct odp_port __force *)compat_ptr(port);
+ return do_dump_port(dp, &dump);
}
static int compat_get_flow(struct odp_flow *flow, const struct compat_odp_flow __user *compat)
{
- compat_uptr_t actions;
+ compat_uptr_t key, 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(key, &compat->key) ||
+ __get_user(flow->key_len, &compat->key_len) ||
__get_user(actions, &compat->actions) ||
__get_user(flow->actions_len, &compat->actions_len) ||
__get_user(flow->flags, &compat->flags))
return -EFAULT;
+ flow->key = (struct nlattr __force *)compat_ptr(key);
flow->actions = (struct nlattr __force *)compat_ptr(actions);
return 0;
}
if (compat_get_flow(&uf, ufp))
return -EFAULT;
- flow = do_del_flow(dp, &uf.key);
+ flow = do_del_flow(dp, (const struct nlattr __force __user *)uf.key, uf.key_len);
if (IS_ERR(flow))
return PTR_ERR(flow);
struct compat_odp_flow __user *ufp = &flows[i];
struct odp_flow uf;
struct tbl_node *flow_node;
+ struct sw_flow_key key;
int error;
if (compat_get_flow(&uf, ufp))
return -EFAULT;
- flow_node = tbl_lookup(table, &uf.key, flow_hash(&uf.key), flow_cmp);
+ error = flow_copy_from_user(&key, (const struct nlattr __force __user *) uf.key, uf.key_len);
+ if (error)
+ return error;
+
+ flow_node = tbl_lookup(table, &key, flow_hash(&key), flow_cmp);
if (!flow_node)
error = put_user(ENOENT, &ufp->stats.error);
else
struct compat_odp_flow __user *uflowp;
compat_uptr_t compat_ufp;
struct sw_flow *flow;
+ compat_uptr_t ukey;
+ u32 key_len;
flow = do_dump_flow(dp, udumpp->state);
if (IS_ERR(flow))
if (!flow)
return put_user(ODPFF_EOF, &uflowp->flags);
- if (copy_to_user(&uflowp->key, &flow->key, sizeof(struct odp_flow_key)) ||
- put_user(0, &uflowp->flags))
+ if (put_user(0, &uflowp->flags) ||
+ get_user(ukey, &uflowp->key) ||
+ get_user(key_len, &uflowp->key_len))
+ return -EFAULT;
+
+ key_len = flow_copy_to_user(compat_ptr(ukey), &flow->key, key_len);
+ if (key_len < 0)
+ return key_len;
+ if (put_user(key_len, &uflowp->key_len))
return -EFAULT;
+
return compat_answer_query(dp, flow, 0, uflowp);
}
goto exit;
switch (cmd) {
- case ODP_VPORT_LIST32:
- err = compat_list_ports(dp, compat_ptr(argp));
+ case ODP_VPORT_DUMP32:
+ err = compat_dump_port(dp, compat_ptr(argp));
break;
case ODP_FLOW_PUT32:
}
#endif
-/* Unfortunately this function is not exported so this is a verbatim copy
- * from net/core/datagram.c in 2.6.30. */
-static int skb_copy_and_csum_datagram(const struct sk_buff *skb, int offset,
- u8 __user *to, int len,
- __wsum *csump)
-{
- int start = skb_headlen(skb);
- int pos = 0;
- int i, copy = start - offset;
-
- /* Copy header. */
- if (copy > 0) {
- int err = 0;
- if (copy > len)
- copy = len;
- *csump = csum_and_copy_to_user(skb->data + offset, to, copy,
- *csump, &err);
- if (err)
- goto fault;
- if ((len -= copy) == 0)
- return 0;
- offset += copy;
- to += copy;
- pos = copy;
- }
-
- for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
- int end;
-
- WARN_ON(start > offset + len);
-
- end = start + skb_shinfo(skb)->frags[i].size;
- if ((copy = end - offset) > 0) {
- __wsum csum2;
- int err = 0;
- u8 *vaddr;
- skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
- struct page *page = frag->page;
-
- if (copy > len)
- copy = len;
- vaddr = kmap(page);
- csum2 = csum_and_copy_to_user(vaddr +
- frag->page_offset +
- offset - start,
- to, copy, 0, &err);
- kunmap(page);
- if (err)
- goto fault;
- *csump = csum_block_add(*csump, csum2, pos);
- if (!(len -= copy))
- return 0;
- offset += copy;
- to += copy;
- pos += copy;
- }
- start = end;
- }
-
- if (skb_shinfo(skb)->frag_list) {
- struct sk_buff *list = skb_shinfo(skb)->frag_list;
-
- for (; list; list=list->next) {
- int end;
-
- WARN_ON(start > offset + len);
-
- end = start + list->len;
- if ((copy = end - offset) > 0) {
- __wsum csum2 = 0;
- if (copy > len)
- copy = len;
- if (skb_copy_and_csum_datagram(list,
- offset - start,
- to, copy,
- &csum2))
- goto fault;
- *csump = csum_block_add(*csump, csum2, pos);
- if ((len -= copy) == 0)
- return 0;
- offset += copy;
- to += copy;
- pos += copy;
- }
- start = end;
- }
- }
- if (!len)
- return 0;
-
-fault:
- return -EFAULT;
-}
-
static ssize_t openvswitch_read(struct file *f, char __user *buf,
size_t nbytes, loff_t *ppos)
{
int dp_idx = iminor(f->f_dentry->d_inode);
struct datapath *dp = get_dp_locked(dp_idx);
struct sk_buff *skb;
- size_t copy_bytes, tot_copy_bytes;
+ struct iovec iov;
int retval;
if (!dp)
success:
mutex_unlock(&dp->mutex);
- copy_bytes = tot_copy_bytes = min_t(size_t, skb->len, nbytes);
-
- retval = 0;
- if (skb->ip_summed == CHECKSUM_PARTIAL) {
- if (copy_bytes == skb->len) {
- __wsum csum = 0;
- u16 csum_start, csum_offset;
-
- get_skb_csum_pointers(skb, &csum_start, &csum_offset);
- csum_start -= skb_headroom(skb);
-
- BUG_ON(csum_start >= skb_headlen(skb));
- retval = skb_copy_and_csum_datagram(skb, csum_start, buf + csum_start,
- copy_bytes - csum_start, &csum);
- if (!retval) {
- __sum16 __user *csump;
-
- copy_bytes = csum_start;
- csump = (__sum16 __user *)(buf + csum_start + csum_offset);
-
- BUG_ON((char __user *)csump + sizeof(__sum16) >
- buf + nbytes);
- put_user(csum_fold(csum), csump);
- }
- } else
- retval = skb_checksum_help(skb);
- }
-
- if (!retval) {
- struct iovec iov;
-
- iov.iov_base = buf;
- iov.iov_len = copy_bytes;
- retval = skb_copy_datagram_iovec(skb, 0, &iov, iov.iov_len);
- }
-
+ iov.iov_base = buf;
+ iov.iov_len = min_t(size_t, skb->len, nbytes);
+ retval = skb_copy_datagram_iovec(skb, 0, &iov, iov.iov_len);
if (!retval)
- retval = tot_copy_bytes;
+ retval = skb->len;
kfree_skb(skb);
return retval;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff