1 /*
2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32 
33 #include <linux/module.h>
34 #include <linux/sched/signal.h>
35 
36 #include <linux/init.h>
37 #include <linux/seq_file.h>
38 
39 #include <linux/uaccess.h>
40 
41 #include "ipoib.h"
42 
43 static ssize_t show_parent(struct device *d, struct device_attribute *attr,
44 			   char *buf)
45 {
46 	struct net_device *dev = to_net_dev(d);
47 	struct ipoib_dev_priv *priv = ipoib_priv(dev);
48 
49 	return sysfs_emit(buf, "%s\n", priv->parent->name);
50 }
51 static DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL);
52 
53 static bool is_child_unique(struct ipoib_dev_priv *ppriv,
54 			    struct ipoib_dev_priv *priv)
55 {
56 	struct ipoib_dev_priv *tpriv;
57 
58 	ASSERT_RTNL();
59 
60 	/*
61 	 * Since the legacy sysfs interface uses pkey for deletion it cannot
62 	 * support more than one interface with the same pkey, it creates
63 	 * ambiguity.  The RTNL interface deletes using the netdev so it does
64 	 * not have a problem to support duplicated pkeys.
65 	 */
66 	if (priv->child_type != IPOIB_LEGACY_CHILD)
67 		return true;
68 
69 	/*
70 	 * First ensure this isn't a duplicate. We check the parent device and
71 	 * then all of the legacy child interfaces to make sure the Pkey
72 	 * doesn't match.
73 	 */
74 	if (ppriv->pkey == priv->pkey)
75 		return false;
76 
77 	list_for_each_entry(tpriv, &ppriv->child_intfs, list) {
78 		if (tpriv->pkey == priv->pkey &&
79 		    tpriv->child_type == IPOIB_LEGACY_CHILD)
80 			return false;
81 	}
82 
83 	return true;
84 }
85 
86 /*
87  * NOTE: If this function fails then the priv->dev will remain valid, however
88  * priv will have been freed and must not be touched by caller in the error
89  * case.
90  *
91  * If (ndev->reg_state == NETREG_UNINITIALIZED) then it is up to the caller to
92  * free the net_device (just as rtnl_newlink does) otherwise the net_device
93  * will be freed when the rtnl is unlocked.
94  */
95 int __ipoib_vlan_add(struct ipoib_dev_priv *ppriv, struct ipoib_dev_priv *priv,
96 		     u16 pkey, int type)
97 {
98 	struct net_device *ndev = priv->dev;
99 	int result;
100 	struct rdma_netdev *rn = netdev_priv(ndev);
101 
102 	ASSERT_RTNL();
103 
104 	/*
105 	 * We do not need to touch priv if register_netdevice fails, so just
106 	 * always use this flow.
107 	 */
108 	ndev->priv_destructor = ipoib_intf_free;
109 
110 	/*
111 	 * Racing with unregister of the parent must be prevented by the
112 	 * caller.
113 	 */
114 	WARN_ON(ppriv->dev->reg_state != NETREG_REGISTERED);
115 
116 	if (pkey == 0 || pkey == 0x8000) {
117 		result = -EINVAL;
118 		goto out_early;
119 	}
120 
121 	rn->mtu = priv->mcast_mtu;
122 
123 	priv->parent = ppriv->dev;
124 	priv->pkey = pkey;
125 	priv->child_type = type;
126 
127 	if (!is_child_unique(ppriv, priv)) {
128 		result = -ENOTUNIQ;
129 		goto out_early;
130 	}
131 
132 	result = register_netdevice(ndev);
133 	if (result) {
134 		ipoib_warn(priv, "failed to initialize; error %i", result);
135 
136 		/*
137 		 * register_netdevice sometimes calls priv_destructor,
138 		 * sometimes not. Make sure it was done.
139 		 */
140 		goto out_early;
141 	}
142 
143 	/* RTNL childs don't need proprietary sysfs entries */
144 	if (type == IPOIB_LEGACY_CHILD) {
145 		if (ipoib_cm_add_mode_attr(ndev))
146 			goto sysfs_failed;
147 		if (ipoib_add_pkey_attr(ndev))
148 			goto sysfs_failed;
149 		if (ipoib_add_umcast_attr(ndev))
150 			goto sysfs_failed;
151 
152 		if (device_create_file(&ndev->dev, &dev_attr_parent))
153 			goto sysfs_failed;
154 	}
155 
156 	return 0;
157 
158 sysfs_failed:
159 	unregister_netdevice(priv->dev);
160 	return -ENOMEM;
161 
162 out_early:
163 	if (ndev->priv_destructor)
164 		ndev->priv_destructor(ndev);
165 	return result;
166 }
167 
168 int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
169 {
170 	struct ipoib_dev_priv *ppriv, *priv;
171 	char intf_name[IFNAMSIZ];
172 	struct net_device *ndev;
173 	int result;
174 
175 	if (!capable(CAP_NET_ADMIN))
176 		return -EPERM;
177 
178 	if (!rtnl_trylock())
179 		return restart_syscall();
180 
181 	if (pdev->reg_state != NETREG_REGISTERED) {
182 		rtnl_unlock();
183 		return -EPERM;
184 	}
185 
186 	ppriv = ipoib_priv(pdev);
187 
188 	snprintf(intf_name, sizeof(intf_name), "%s.%04x",
189 		 ppriv->dev->name, pkey);
190 
191 	ndev = ipoib_intf_alloc(ppriv->ca, ppriv->port, intf_name);
192 	if (IS_ERR(ndev)) {
193 		result = PTR_ERR(ndev);
194 		goto out;
195 	}
196 	priv = ipoib_priv(ndev);
197 
198 	ndev->rtnl_link_ops = ipoib_get_link_ops();
199 
200 	result = __ipoib_vlan_add(ppriv, priv, pkey, IPOIB_LEGACY_CHILD);
201 
202 	if (result && ndev->reg_state == NETREG_UNINITIALIZED)
203 		free_netdev(ndev);
204 
205 out:
206 	rtnl_unlock();
207 
208 	return result;
209 }
210 
211 struct ipoib_vlan_delete_work {
212 	struct work_struct work;
213 	struct net_device *dev;
214 };
215 
216 /*
217  * sysfs callbacks of a netdevice cannot obtain the rtnl lock as
218  * unregister_netdev ultimately deletes the sysfs files while holding the rtnl
219  * lock. This deadlocks the system.
220  *
221  * A callback can use rtnl_trylock to avoid the deadlock but it cannot call
222  * unregister_netdev as that internally takes and releases the rtnl_lock.  So
223  * instead we find the netdev to unregister and then do the actual unregister
224  * from the global work queue where we can obtain the rtnl_lock safely.
225  */
226 static void ipoib_vlan_delete_task(struct work_struct *work)
227 {
228 	struct ipoib_vlan_delete_work *pwork =
229 		container_of(work, struct ipoib_vlan_delete_work, work);
230 	struct net_device *dev = pwork->dev;
231 
232 	rtnl_lock();
233 
234 	/* Unregistering tasks can race with another task or parent removal */
235 	if (dev->reg_state == NETREG_REGISTERED) {
236 		struct ipoib_dev_priv *priv = ipoib_priv(dev);
237 		struct ipoib_dev_priv *ppriv = ipoib_priv(priv->parent);
238 
239 		ipoib_dbg(ppriv, "delete child vlan %s\n", dev->name);
240 		unregister_netdevice(dev);
241 	}
242 
243 	rtnl_unlock();
244 
245 	kfree(pwork);
246 }
247 
248 int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
249 {
250 	struct ipoib_dev_priv *ppriv, *priv, *tpriv;
251 	int rc;
252 
253 	if (!capable(CAP_NET_ADMIN))
254 		return -EPERM;
255 
256 	if (!rtnl_trylock())
257 		return restart_syscall();
258 
259 	if (pdev->reg_state != NETREG_REGISTERED) {
260 		rtnl_unlock();
261 		return -EPERM;
262 	}
263 
264 	ppriv = ipoib_priv(pdev);
265 
266 	rc = -ENODEV;
267 	list_for_each_entry_safe(priv, tpriv, &ppriv->child_intfs, list) {
268 		if (priv->pkey == pkey &&
269 		    priv->child_type == IPOIB_LEGACY_CHILD) {
270 			struct ipoib_vlan_delete_work *work;
271 
272 			work = kmalloc(sizeof(*work), GFP_KERNEL);
273 			if (!work) {
274 				rc = -ENOMEM;
275 				goto out;
276 			}
277 
278 			down_write(&ppriv->vlan_rwsem);
279 			list_del_init(&priv->list);
280 			up_write(&ppriv->vlan_rwsem);
281 			work->dev = priv->dev;
282 			INIT_WORK(&work->work, ipoib_vlan_delete_task);
283 			queue_work(ipoib_workqueue, &work->work);
284 
285 			rc = 0;
286 			break;
287 		}
288 	}
289 
290 out:
291 	rtnl_unlock();
292 
293 	return rc;
294 }
295