X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=datapath%2Fdatapath.c;h=abc559935b710a00fc4dbb0fda70ada639237a15;hb=1b378b99f638212216f2090cb7be7efab3d90c14;hp=fc73cac3d8336a71842671212274a973e4ffbfe5;hpb=a14bc59fb8f27db193d74662dc9c5cb8237177ef;p=openvswitch

diff --git a/datapath/datapath.c b/datapath/datapath.c
index fc73cac3..abc55993 100644
--- a/datapath/datapath.c
+++ b/datapath/datapath.c
@@ -55,18 +55,6 @@
 int (*dp_ioctl_hook)(struct net_device *dev, struct ifreq *rq, int cmd);
 EXPORT_SYMBOL(dp_ioctl_hook);
 
-int (*dp_add_dp_hook)(struct datapath *dp);
-EXPORT_SYMBOL(dp_add_dp_hook);
-
-int (*dp_del_dp_hook)(struct datapath *dp);
-EXPORT_SYMBOL(dp_del_dp_hook);
-
-int (*dp_add_if_hook)(struct net_bridge_port *p);
-EXPORT_SYMBOL(dp_add_if_hook);
-
-int (*dp_del_if_hook)(struct net_bridge_port *p);
-EXPORT_SYMBOL(dp_del_if_hook);
-
 /* Datapaths.  Protected on the read side by rcu_read_lock, on the write side
  * by dp_mutex.  dp_mutex is almost completely redundant with genl_mutex
  * maintained by the Generic Netlink code, but the timeout path needs mutual
@@ -183,6 +171,16 @@ errout:
 		rtnl_set_sk_err(net, RTNLGRP_LINK, err);
 }
 
+static void release_dp(struct kobject *kobj)
+{
+	struct datapath *dp = container_of(kobj, struct datapath, ifobj);
+	kfree(dp);
+}
+
+struct kobj_type dp_ktype = {
+	.release = release_dp
+};
+
 static int create_dp(int dp_idx, const char __user *devnamep)
 {
 	struct net_device *dp_dev;
@@ -217,28 +215,37 @@ static int create_dp(int dp_idx, const char __user *devnamep)
 	dp = kzalloc(sizeof *dp, GFP_KERNEL);
 	if (dp == NULL)
 		goto err_put_module;
-
+	INIT_LIST_HEAD(&dp->port_list);
 	mutex_init(&dp->mutex);
 	dp->dp_idx = dp_idx;
 	for (i = 0; i < DP_N_QUEUES; i++)
 		skb_queue_head_init(&dp->queues[i]);
 	init_waitqueue_head(&dp->waitqueue);
 
-	/* Setup our datapath device */
-	dp_dev = dp_dev_create(dp, devname, ODPP_LOCAL);
-	err = PTR_ERR(dp_dev);
-	if (IS_ERR(dp_dev))
-		goto err_free_dp;
+	/* Initialize kobject for bridge.  This will be added as
+	 * /sys/class/net/<devname>/brif later, if sysfs is enabled. */
+	kobject_set_name(&dp->ifobj, SYSFS_BRIDGE_PORT_SUBDIR); /* "brif" */
+	dp->ifobj.kset = NULL;
+	dp->ifobj.parent = NULL;
+	kobject_init(&dp->ifobj, &dp_ktype);
 
+	/* Allocate table. */
 	err = -ENOMEM;
 	rcu_assign_pointer(dp->table, dp_table_create(DP_L1_SIZE));
 	if (!dp->table)
-		goto err_destroy_dp_dev;
-	INIT_LIST_HEAD(&dp->port_list);
+		goto err_free_dp;
+
+	/* Setup our datapath device */
+	dp_dev = dp_dev_create(dp, devname, ODPP_LOCAL);
+	err = PTR_ERR(dp_dev);
+	if (IS_ERR(dp_dev))
+		goto err_destroy_table;
 
 	err = new_nbp(dp, dp_dev, ODPP_LOCAL);
-	if (err)
+	if (err) {
+		dp_dev_destroy(dp_dev);
 		goto err_destroy_table;
+	}
 
 	dp->drop_frags = 0;
 	dp->stats_percpu = alloc_percpu(struct dp_stats_percpu);
@@ -249,17 +256,16 @@ static int create_dp(int dp_idx, const char __user *devnamep)
 	mutex_unlock(&dp_mutex);
 	rtnl_unlock();
 
-	if (dp_add_dp_hook)
-		dp_add_dp_hook(dp);
+#ifdef SUPPORT_SYSFS
+	dp_sysfs_add_dp(dp);
+#endif
 
 	return 0;
 
 err_destroy_local_port:
-	dp_del_port(dp->ports[ODPP_LOCAL], NULL);
+	dp_del_port(dp->ports[ODPP_LOCAL]);
 err_destroy_table:
 	dp_table_destroy(dp->table, 0);
-err_destroy_dp_dev:
-	dp_dev_destroy(dp_dev);
 err_free_dp:
 	kfree(dp);
 err_put_module:
@@ -271,38 +277,37 @@ err:
 	return err;
 }
 
-static void do_destroy_dp(struct datapath *dp, struct list_head *dp_devs)
+static void do_destroy_dp(struct datapath *dp)
 {
 	struct net_bridge_port *p, *n;
 	int i;
 
-	if (dp_del_dp_hook)
-		dp_del_dp_hook(dp);
-
-	/* Drop references to DP. */
 	list_for_each_entry_safe (p, n, &dp->port_list, node)
-		dp_del_port(p, dp_devs);
+		if (p->port_no != ODPP_LOCAL)
+			dp_del_port(p);
+
+#ifdef SUPPORT_SYSFS
+	dp_sysfs_del_dp(dp);
+#endif
 
 	rcu_assign_pointer(dps[dp->dp_idx], NULL);
-	synchronize_rcu();
 
-	/* Wait until no longer in use, then destroy it. */
-	synchronize_rcu();
+	dp_del_port(dp->ports[ODPP_LOCAL]);
+
 	dp_table_destroy(dp->table, 1);
+
 	for (i = 0; i < DP_N_QUEUES; i++)
 		skb_queue_purge(&dp->queues[i]);
 	for (i = 0; i < DP_MAX_GROUPS; i++)
 		kfree(dp->groups[i]);
 	free_percpu(dp->stats_percpu);
-	kfree(dp);
+	kobject_put(&dp->ifobj);
 	module_put(THIS_MODULE);
 }
 
 static int destroy_dp(int dp_idx)
 {
-	struct dp_dev *dp_dev, *next;
 	struct datapath *dp;
-	LIST_HEAD(dp_devs);
 	int err;
 
 	rtnl_lock();
@@ -312,17 +317,28 @@ static int destroy_dp(int dp_idx)
 	if (!dp)
 		goto err_unlock;
 
-	do_destroy_dp(dp, &dp_devs);
+	do_destroy_dp(dp);
 	err = 0;
 
 err_unlock:
 	mutex_unlock(&dp_mutex);
 	rtnl_unlock();
-	list_for_each_entry_safe (dp_dev, next, &dp_devs, list)
-		free_netdev(dp_dev->dev);
 	return err;
 }
 
+static void release_nbp(struct kobject *kobj)
+{
+	struct net_bridge_port *p = container_of(kobj, struct net_bridge_port, kobj);
+	kfree(p);
+}
+
+struct kobj_type brport_ktype = {
+#ifdef SUPPORT_SYSFS
+	.sysfs_ops = &brport_sysfs_ops,
+#endif
+	.release = release_nbp
+};
+
 /* Called with RTNL lock and dp_mutex. */
 static int new_nbp(struct datapath *dp, struct net_device *dev, int port_no)
 {
@@ -352,6 +368,13 @@ static int new_nbp(struct datapath *dp, struct net_device *dev, int port_no)
 	list_add_rcu(&p->node, &dp->port_list);
 	dp->n_ports++;
 
+	/* Initialize kobject for bridge.  This will be added as
+	 * /sys/class/net/<devname>/brport later, if sysfs is enabled. */
+	kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR); /* "brport" */
+	p->kobj.kset = NULL;
+	p->kobj.parent = &p->dev->NETDEV_DEV_MEMBER.kobj;
+	kobject_init(&p->kobj, &brport_ktype);
+
 	dp_ifinfo_notify(RTM_NEWLINK, p);
 
 	return 0;
@@ -407,8 +430,9 @@ static int add_port(int dp_idx, struct odp_port __user *portp)
 	if (err)
 		goto out_put;
 
-	if (dp_add_if_hook)
-		dp_add_if_hook(dp->ports[port_no]);
+#ifdef SUPPORT_SYSFS
+	dp_sysfs_add_if(dp->ports[port_no]);
+#endif
 
 out_put:
 	dev_put(dev);
@@ -420,13 +444,13 @@ out:
 	return err;
 }
 
-int dp_del_port(struct net_bridge_port *p, struct list_head *dp_devs)
+int dp_del_port(struct net_bridge_port *p)
 {
 	ASSERT_RTNL();
 
 #ifdef SUPPORT_SYSFS
-	if (p->port_no != ODPP_LOCAL && dp_del_if_hook)
-		sysfs_remove_link(&p->dp->ifobj, p->dev->name);
+	if (p->port_no != ODPP_LOCAL)
+		dp_sysfs_del_if(p);
 #endif
 	dp_ifinfo_notify(RTM_DELLINK, p);
 
@@ -448,26 +472,16 @@ int dp_del_port(struct net_bridge_port *p, struct list_head *dp_devs)
 	/* Then wait until no one is still using it, and destroy it. */
 	synchronize_rcu();
 
-	if (is_dp_dev(p->dev)) {
+	if (is_dp_dev(p->dev))
 		dp_dev_destroy(p->dev);
-		if (dp_devs) {
-			struct dp_dev *dp_dev = dp_dev_priv(p->dev);
-			list_add(&dp_dev->list, dp_devs);
-		}
-	}
-	if (p->port_no != ODPP_LOCAL && dp_del_if_hook) {
-		dp_del_if_hook(p);
-	} else {
-		dev_put(p->dev);
-		kfree(p);
-	}
+	dev_put(p->dev);
+	kobject_put(&p->kobj);
 
 	return 0;
 }
 
 static int del_port(int dp_idx, int port_no)
 {
-	struct dp_dev *dp_dev, *next;
 	struct net_bridge_port *p;
 	struct datapath *dp;
 	LIST_HEAD(dp_devs);
@@ -488,15 +502,13 @@ static int del_port(int dp_idx, int port_no)
 	if (!p)
 		goto out_unlock_dp;
 
-	err = dp_del_port(p, &dp_devs);
+	err = dp_del_port(p);
 
 out_unlock_dp:
 	mutex_unlock(&dp->mutex);
 out_unlock_rtnl:
 	rtnl_unlock();
 out:
-	list_for_each_entry_safe (dp_dev, next, &dp_devs, list)
-		free_netdev(dp_dev->dev);
 	return err;
 }
 
@@ -527,7 +539,6 @@ void dp_process_received_packet(struct sk_buff *skb, struct net_bridge_port *p)
 	struct sw_flow *flow;
 
 	WARN_ON_ONCE(skb_shared(skb));
-	WARN_ON_ONCE(skb->destructor);
 
 	/* BHs are off so we don't have to use get_cpu()/put_cpu() here. */
 	stats = percpu_ptr(dp->stats_percpu, smp_processor_id());
@@ -772,7 +783,8 @@ static int validate_actions(const struct sw_flow_actions *actions)
 			break;
 
 		case ODPAT_SET_VLAN_PCP:
-			if (a->vlan_pcp.vlan_pcp & ~VLAN_PCP_MASK)
+			if (a->vlan_pcp.vlan_pcp
+			    & ~(VLAN_PCP_MASK >> VLAN_PCP_SHIFT))
 				return -EINVAL;
 			break;
 
@@ -839,7 +851,7 @@ static void clear_stats(struct sw_flow *flow)
 static int put_flow(struct datapath *dp, struct odp_flow_put __user *ufp)
 {
 	struct odp_flow_put uf;
-	struct sw_flow *flow, **bucket;
+	struct sw_flow *flow;
 	struct dp_table *table;
 	struct odp_flow_stats stats;
 	int error;
@@ -849,15 +861,10 @@ static int put_flow(struct datapath *dp, struct odp_flow_put __user *ufp)
 		goto error;
 	uf.flow.key.reserved = 0;
 
-retry:
 	table = rcu_dereference(dp->table);
-	bucket = dp_table_lookup_for_insert(table, &uf.flow.key);
-	if (!bucket) {
-		/* No such flow, and the slots where it could go are full. */
-		error = uf.flags & ODPPF_CREATE ? -EXFULL : -ENOENT;
-		goto error;
-	} else if (!*bucket) {
-		/* No such flow, but we found an available slot for it. */
+	flow = dp_table_lookup(table, &uf.flow.key);
+	if (!flow) {
+		/* No such flow. */
 		struct sw_flow_actions *acts;
 
 		error = -ENOENT;
@@ -865,14 +872,15 @@ retry:
 			goto error;
 
 		/* Expand table, if necessary, to make room. */
-		if (dp->n_flows * 4 >= table->n_buckets &&
-		    table->n_buckets < DP_MAX_BUCKETS) {
+		if (dp->n_flows >= table->n_buckets) {
+			error = -ENOSPC;
+			if (table->n_buckets >= DP_MAX_BUCKETS)
+				goto error;
+
 			error = dp_table_expand(dp);
 			if (error)
 				goto error;
-
-			/* The bucket's location has changed.  Try again. */
-			goto retry;
+			table = rcu_dereference(dp->table);
 		}
 
 		/* Allocate flow. */
@@ -892,12 +900,13 @@ retry:
 		rcu_assign_pointer(flow->sf_acts, acts);
 
 		/* Put flow in bucket. */
-		rcu_assign_pointer(*bucket, flow);
+		error = dp_table_insert(table, flow);
+		if (error)
+			goto error_free_flow_acts;
 		dp->n_flows++;
 		memset(&stats, 0, sizeof(struct odp_flow_stats));
 	} else {
 		/* We found a matching flow. */
-		struct sw_flow *flow = *rcu_dereference(bucket);
 		struct sw_flow_actions *old_acts, *new_acts;
 		unsigned long int flags;
 
@@ -935,6 +944,8 @@ retry:
 		return -EFAULT;
 	return 0;
 
+error_free_flow_acts:
+	kfree(flow->sf_acts);
 error_free_flow:
 	kmem_cache_free(flow_cache, flow);
 error:
@@ -1117,6 +1128,7 @@ static int do_execute(struct datapath *dp, const struct odp_execute *executep)
 	struct odp_flow_key key;
 	struct sk_buff *skb;
 	struct sw_flow_actions *actions;
+	struct ethhdr *eth;
 	int err;
 
 	err = -EFAULT;
@@ -1156,6 +1168,17 @@ static int do_execute(struct datapath *dp, const struct odp_execute *executep)
 			   execute.length))
 		goto error_free_skb;
 
+	skb_reset_mac_header(skb);
+	eth = eth_hdr(skb);
+
+    /* Normally, setting the skb 'protocol' field would be handled by a
+     * call to eth_type_trans(), but it assumes there's a sending
+     * device, which we may not have. */
+	if (ntohs(eth->h_proto) >= 1536)
+		skb->protocol = eth->h_proto;
+	else
+		skb->protocol = htons(ETH_P_802_2);
+
 	flow_extract(skb, execute.in_port, &key);
 	err = execute_actions(dp, skb, &key, actions->actions,
 			      actions->n_actions, GFP_KERNEL);
@@ -1177,8 +1200,8 @@ get_dp_stats(struct datapath *dp, struct odp_stats __user *statsp)
 	int i;
 
 	stats.n_flows = dp->n_flows;
-	stats.cur_capacity = rcu_dereference(dp->table)->n_buckets * 2;
-	stats.max_capacity = DP_MAX_BUCKETS * 2;
+	stats.cur_capacity = rcu_dereference(dp->table)->n_buckets;
+	stats.max_capacity = DP_MAX_BUCKETS;
 	stats.n_ports = dp->n_ports;
 	stats.max_ports = DP_MAX_PORTS;
 	stats.max_groups = DP_MAX_GROUPS;
@@ -1196,6 +1219,29 @@ get_dp_stats(struct datapath *dp, struct odp_stats __user *statsp)
 	return copy_to_user(statsp, &stats, sizeof stats) ? -EFAULT : 0;
 }
 
+/* MTU of the dp pseudo-device: ETH_DATA_LEN or the minimum of the ports */
+int dp_min_mtu(const struct datapath *dp)
+{
+	struct net_bridge_port *p;
+	int mtu = 0;
+
+	ASSERT_RTNL();
+
+	list_for_each_entry_rcu (p, &dp->port_list, node) {
+		struct net_device *dev = p->dev;
+
+		/* Skip any internal ports, since that's what we're trying to
+		 * set. */
+		if (is_dp_dev(dev))
+			continue;
+
+		if (!mtu || dev->mtu < mtu)
+			mtu = dev->mtu;
+	}
+
+	return mtu ? mtu : ETH_DATA_LEN;
+}
+
 static int
 put_port(const struct net_bridge_port *p, struct odp_port __user *uop)
 {
@@ -1336,6 +1382,16 @@ get_port_group(struct datapath *dp, struct odp_port_group *upg)
 	return 0;
 }
 
+static int get_listen_mask(const struct file *f)
+{
+	return (long)f->private_data;
+}
+
+static void set_listen_mask(struct file *f, int listen_mask)
+{
+	f->private_data = (void*)(long)listen_mask;
+}
+
 static long openvswitch_ioctl(struct file *f, unsigned int cmd,
 			   unsigned long argp)
 {
@@ -1387,7 +1443,7 @@ static long openvswitch_ioctl(struct file *f, unsigned int cmd,
 		break;
 
 	case ODP_GET_LISTEN_MASK:
-		err = put_user((int)f->private_data, (int __user *)argp);
+		err = put_user(get_listen_mask(f), (int __user *)argp);
 		break;
 
 	case ODP_SET_LISTEN_MASK:
@@ -1398,7 +1454,7 @@ static long openvswitch_ioctl(struct file *f, unsigned int cmd,
 		if (listeners & ~ODPL_ALL)
 			break;
 		err = 0;
-		f->private_data = (void*)listeners;
+		set_listen_mask(f, listeners);
 		break;
 
 	case ODP_PORT_QUERY:
@@ -1464,7 +1520,8 @@ static int dp_has_packet_of_interest(struct datapath *dp, int listeners)
 ssize_t openvswitch_read(struct file *f, char __user *buf, size_t nbytes,
 		      loff_t *ppos)
 {
-	int listeners = (int) f->private_data;
+	/* XXX is there sufficient synchronization here? */
+	int listeners = get_listen_mask(f);
 	int dp_idx = iminor(f->f_dentry->d_inode);
 	struct datapath *dp = get_dp(dp_idx);
 	struct sk_buff *skb;
@@ -1504,7 +1561,7 @@ ssize_t openvswitch_read(struct file *f, char __user *buf, size_t nbytes,
 		}
 	}
 success:
-	copy_bytes = min(skb->len, nbytes);
+	copy_bytes = min_t(size_t, skb->len, nbytes);
 	iov.iov_base = buf;
 	iov.iov_len = copy_bytes;
 	retval = skb_copy_datagram_iovec(skb, 0, &iov, iov.iov_len);
@@ -1518,6 +1575,7 @@ error:
 
 static unsigned int openvswitch_poll(struct file *file, poll_table *wait)
 {
+	/* XXX is there sufficient synchronization here? */
 	int dp_idx = iminor(file->f_dentry->d_inode);
 	struct datapath *dp = get_dp(dp_idx);
 	unsigned int mask;
@@ -1525,7 +1583,7 @@ static unsigned int openvswitch_poll(struct file *file, poll_table *wait)
 	if (dp) {
 		mask = 0;
 		poll_wait(file, &dp->waitqueue, wait);
-		if (dp_has_packet_of_interest(dp, (int)file->private_data))
+		if (dp_has_packet_of_interest(dp, get_listen_mask(file)))
 			mask |= POLLIN | POLLRDNORM;
 	} else {
 		mask = POLLIN | POLLRDNORM | POLLHUP;