drivers/infiniband/ulp/ipoib/ipoib_vlan.c

   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 sprintf(buf, "%s\n", priv->parent->name);
  50 }
  51 static DEVICE_ATTR(parent, S_IRUGO, show_parent, NULL);
  52
  53 /*
  54  * NOTE: If this function fails then the priv->dev will remain valid, however
  55  * priv can have been freed and must not be touched by caller in the error
  56  * case.
  57  *
  58  * If (ndev->reg_state == NETREG_UNINITIALIZED) then it is up to the caller to
  59  * free the net_device (just as rtnl_newlink does) otherwise the net_device
  60  * will be freed when the rtnl is unlocked.
  61  */
  62 int __ipoib_vlan_add(struct ipoib_dev_priv *ppriv, struct ipoib_dev_priv *priv,
  63                      u16 pkey, int type)
  64 {
  65         struct net_device *ndev = priv->dev;
  66         int result;
  67
  68         ASSERT_RTNL();
  69
  70         priv->parent = ppriv->dev;
  71         priv->pkey = pkey;
  72         priv->child_type = type;
  73
  74         /* We do not need to touch priv if register_netdevice fails */
  75         ndev->priv_destructor = ipoib_intf_free;
  76
  77         result = register_netdevice(ndev);
  78         if (result) {
  79                 ipoib_warn(priv, "failed to initialize; error %i", result);
  80
  81                 /*
  82                  * register_netdevice sometimes calls priv_destructor,
  83                  * sometimes not. Make sure it was done.
  84                  */
  85                 if (ndev->priv_destructor)
  86                         ndev->priv_destructor(ndev);
  87                 return result;
  88         }
  89
  90         /* RTNL childs don't need proprietary sysfs entries */
  91         if (type == IPOIB_LEGACY_CHILD) {
  92                 if (ipoib_cm_add_mode_attr(ndev))
  93                         goto sysfs_failed;
  94                 if (ipoib_add_pkey_attr(ndev))
  95                         goto sysfs_failed;
  96                 if (ipoib_add_umcast_attr(ndev))
  97                         goto sysfs_failed;
  98
  99                 if (device_create_file(&ndev->dev, &dev_attr_parent))
 100                         goto sysfs_failed;
 101         }
 102
 103         list_add_tail(&priv->list, &ppriv->child_intfs);
 104
 105         return 0;
 106
 107 sysfs_failed:
 108         unregister_netdevice(priv->dev);
 109         return -ENOMEM;
 110 }
 111
 112 int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
 113 {
 114         struct ipoib_dev_priv *ppriv, *priv;
 115         char intf_name[IFNAMSIZ];
 116         struct net_device *ndev;
 117         struct ipoib_dev_priv *tpriv;
 118         int result;
 119
 120         if (!capable(CAP_NET_ADMIN))
 121                 return -EPERM;
 122
 123         ppriv = ipoib_priv(pdev);
 124
 125         snprintf(intf_name, sizeof(intf_name), "%s.%04x",
 126                  ppriv->dev->name, pkey);
 127
 128         if (!mutex_trylock(&ppriv->sysfs_mutex))
 129                 return restart_syscall();
 130
 131         if (!rtnl_trylock()) {
 132                 mutex_unlock(&ppriv->sysfs_mutex);
 133                 return restart_syscall();
 134         }
 135
 136         if (pdev->reg_state != NETREG_REGISTERED) {
 137                 rtnl_unlock();
 138                 mutex_unlock(&ppriv->sysfs_mutex);
 139                 return -EPERM;
 140         }
 141
 142         if (!down_write_trylock(&ppriv->vlan_rwsem)) {
 143                 rtnl_unlock();
 144                 mutex_unlock(&ppriv->sysfs_mutex);
 145                 return restart_syscall();
 146         }
 147
 148         /*
 149          * First ensure this isn't a duplicate. We check the parent device and
 150          * then all of the legacy child interfaces to make sure the Pkey
 151          * doesn't match.
 152          */
 153         if (ppriv->pkey == pkey) {
 154                 result = -ENOTUNIQ;
 155                 goto out;
 156         }
 157
 158         list_for_each_entry(tpriv, &ppriv->child_intfs, list) {
 159                 if (tpriv->pkey == pkey &&
 160                     tpriv->child_type == IPOIB_LEGACY_CHILD) {
 161                         result = -ENOTUNIQ;
 162                         goto out;
 163                 }
 164         }
 165
 166         priv = ipoib_intf_alloc(ppriv->ca, ppriv->port, intf_name);
 167         if (!priv) {
 168                 result = -ENOMEM;
 169                 goto out;
 170         }
 171         ndev = priv->dev;
 172
 173         result = __ipoib_vlan_add(ppriv, priv, pkey, IPOIB_LEGACY_CHILD);
 174
 175         if (result && ndev->reg_state == NETREG_UNINITIALIZED)
 176                 free_netdev(ndev);
 177
 178 out:
 179         up_write(&ppriv->vlan_rwsem);
 180         rtnl_unlock();
 181         mutex_unlock(&ppriv->sysfs_mutex);
 182
 183         return result;
 184 }
 185
 186 int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
 187 {
 188         struct ipoib_dev_priv *ppriv, *priv, *tpriv;
 189         struct net_device *dev = NULL;
 190
 191         if (!capable(CAP_NET_ADMIN))
 192                 return -EPERM;
 193
 194         ppriv = ipoib_priv(pdev);
 195
 196         if (!mutex_trylock(&ppriv->sysfs_mutex))
 197                 return restart_syscall();
 198
 199         if (!rtnl_trylock()) {
 200                 mutex_unlock(&ppriv->sysfs_mutex);
 201                 return restart_syscall();
 202         }
 203
 204         if (pdev->reg_state != NETREG_REGISTERED) {
 205                 rtnl_unlock();
 206                 mutex_unlock(&ppriv->sysfs_mutex);
 207                 return -EPERM;
 208         }
 209
 210         if (!down_write_trylock(&ppriv->vlan_rwsem)) {
 211                 rtnl_unlock();
 212                 mutex_unlock(&ppriv->sysfs_mutex);
 213                 return restart_syscall();
 214         }
 215
 216         list_for_each_entry_safe(priv, tpriv, &ppriv->child_intfs, list) {
 217                 if (priv->pkey == pkey &&
 218                     priv->child_type == IPOIB_LEGACY_CHILD) {
 219                         list_del(&priv->list);
 220                         dev = priv->dev;
 221                         break;
 222                 }
 223         }
 224         up_write(&ppriv->vlan_rwsem);
 225
 226         if (dev) {
 227                 ipoib_dbg(ppriv, "delete child vlan %s\n", dev->name);
 228                 unregister_netdevice(dev);
 229         }
 230
 231         rtnl_unlock();
 232         mutex_unlock(&ppriv->sysfs_mutex);
 233
 234         return (dev) ? 0 : -ENODEV;
 235 }