usr/src/uts/common/io/bpf/bpf_mod.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <sys/types.h>
  28 #include <sys/param.h>
  29 #include <sys/stat.h>
  30 #include <sys/errno.h>
  31 #include <sys/uio.h>
  32 #include <sys/buf.h>
  33 #include <sys/modctl.h>
  34 #include <sys/open.h>
  35 #include <sys/kmem.h>
  36 #include <sys/conf.h>
  37 #include <sys/cmn_err.h>
  38 #include <sys/cred.h>
  39 #include <sys/sunddi.h>
  40 #include <sys/mac_provider.h>
  41 #include <sys/dls_impl.h>
  42 #include <inet/ipnet.h>
  43
  44 extern  int     bpfopen(dev_t *devp, int flag, int otyp, cred_t *cred);
  45 extern  int     bpfclose(dev_t dev, int flag, int otyp, cred_t *cred);
  46 extern  int     bpfread(dev_t dev, struct uio *uio_p, cred_t *cred_p);
  47 extern  int     bpfwrite(dev_t dev, struct uio *uio, cred_t *cred);
  48 extern  int     bpfchpoll(dev_t, short, int, short *, struct pollhead **);
  49 extern  int     bpfioctl(dev_t, int, intptr_t, int, cred_t *, int *);
  50 extern  int     bpfilterattach(void);
  51 extern  int     bpfilterdetach(void);
  52
  53 extern  bpf_provider_t  bpf_mac;
  54 extern  bpf_provider_t  bpf_ipnet;
  55
  56 static  int     bpf_attach(dev_info_t *, ddi_attach_cmd_t);
  57 static  void    *bpf_create_inst(const netid_t);
  58 static  void    bpf_destroy_inst(const netid_t, void *);
  59 static  int     bpf_detach(dev_info_t *, ddi_detach_cmd_t);
  60 static  int     bpf_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
  61 static  int     bpf_provider_add(bpf_provider_t *);
  62 static  int     bpf_provider_remove(bpf_provider_t *);
  63 static  void    bpf_shutdown_inst(const netid_t, void *);
  64
  65 extern  void    bpfdetach(uintptr_t);
  66 extern  int     bpf_bufsize;
  67 extern  int     bpf_maxbufsize;
  68
  69 bpf_provider_head_t bpf_providers;
  70
  71 static struct cb_ops bpf_cb_ops = {
  72         bpfopen,
  73         bpfclose,
  74         nodev,          /* strategy */
  75         nodev,          /* print */
  76         nodev,          /* dump */
  77         bpfread,
  78         bpfwrite,       /* write */
  79         bpfioctl,       /* ioctl */
  80         nodev,          /* devmap */
  81         nodev,          /* mmap */
  82         nodev,          /* segmap */
  83         bpfchpoll,      /* poll */
  84         ddi_prop_op,
  85         NULL,
  86         D_MTSAFE,
  87         CB_REV,
  88         nodev,          /* aread */
  89         nodev,          /* awrite */
  90 };
  91
  92 static struct dev_ops bpf_ops = {
  93         DEVO_REV,
  94         0,
  95         bpf_getinfo,
  96         nulldev,
  97         nulldev,
  98         bpf_attach,
  99         bpf_detach,
 100         nodev,          /* reset */
 101         &bpf_cb_ops,
 102         NULL
 103 };
 104
 105 extern struct mod_ops mod_driverops;
 106 static struct modldrv bpfmod = {
 107         &mod_driverops, "Berkely Packet Filter", &bpf_ops
 108 };
 109 static struct modlinkage modlink1 = { MODREV_1, &bpfmod, NULL };
 110
 111 static dev_info_t *bpf_dev_info = NULL;
 112 static net_instance_t *bpf_inst = NULL;
 113
 114 int
 115 _init()
 116 {
 117         int bpfinst;
 118
 119         bpfinst = mod_install(&modlink1);
 120         return (bpfinst);
 121 }
 122
 123 int
 124 _fini(void)
 125 {
 126         int bpfinst;
 127
 128         bpfinst = mod_remove(&modlink1);
 129         return (bpfinst);
 130 }
 131
 132 int
 133 _info(struct modinfo *modinfop)
 134 {
 135         int bpfinst;
 136
 137         bpfinst = mod_info(&modlink1, modinfop);
 138         return (bpfinst);
 139 }
 140
 141 static int
 142 bpf_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 143 {
 144
 145         switch (cmd) {
 146         case DDI_ATTACH:
 147                 /*
 148                  * Default buffer size from bpf's driver.conf file
 149                  */
 150                 bpf_bufsize = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
 151                     "buf_size", 32 * 1024);
 152                 /*
 153                  * Maximum buffer size from bpf's driver.conf file
 154                  */
 155                 bpf_maxbufsize = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
 156                     "max_buf_size", 16 * 1024 * 1024);
 157
 158                 if (ddi_create_minor_node(dip, "bpf", S_IFCHR, 0,
 159                     DDI_PSEUDO, 0) == DDI_FAILURE) {
 160                         ddi_remove_minor_node(dip, NULL);
 161                         goto attach_failed;
 162                 }
 163                 bpf_dev_info = dip;
 164                 ddi_report_dev(dip);
 165
 166                 LIST_INIT(&bpf_providers);
 167
 168                 if (bpfilterattach() != 0)
 169                         goto attach_failed;
 170
 171                 ipnet_set_itap(bpf_itap);
 172                 VERIFY(bpf_provider_add(&bpf_ipnet) == 0);
 173                 VERIFY(bpf_provider_add(&bpf_mac) == 0);
 174
 175                 /*
 176                  * Set up to be notified about zones coming and going
 177                  * so that proper interaction with ipnet is possible.
 178                  */
 179                 bpf_inst = net_instance_alloc(NETINFO_VERSION);
 180                 if (bpf_inst == NULL)
 181                         goto attach_failed;
 182                 bpf_inst->nin_name = "bpf";
 183                 bpf_inst->nin_create = bpf_create_inst;
 184                 bpf_inst->nin_destroy = bpf_destroy_inst;
 185                 bpf_inst->nin_shutdown = bpf_shutdown_inst;
 186                 if (net_instance_register(bpf_inst) != 0) {
 187                         net_instance_free(bpf_inst);
 188                         goto attach_failed;
 189                 }
 190
 191                 return (DDI_SUCCESS);
 192                 /* NOTREACHED */
 193         case DDI_RESUME:
 194                 return (DDI_SUCCESS);
 195                 /* NOTREACHED */
 196         default:
 197                 break;
 198         }
 199
 200 attach_failed:
 201
 202         /*
 203          * Use our own detach routine to toss
 204          * away any stuff we allocated above.
 205          */
 206         (void) bpfilterdetach();
 207         (void) bpf_detach(dip, DDI_DETACH);
 208         return (DDI_FAILURE);
 209 }
 210
 211 static int
 212 bpf_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 213 {
 214         int error;
 215
 216         switch (cmd) {
 217         case DDI_DETACH:
 218                 if (net_instance_unregister(bpf_inst) != 0)
 219                         return (DDI_FAILURE);
 220                 net_instance_free(bpf_inst);
 221
 222                 ipnet_set_itap(NULL);
 223                 error = bpfilterdetach();
 224                 if (error != 0)
 225                         return (DDI_FAILURE);
 226                 VERIFY(bpf_provider_remove(&bpf_ipnet) == 0);
 227                 VERIFY(bpf_provider_remove(&bpf_mac) == 0);
 228
 229                 ASSERT(LIST_EMPTY(&bpf_providers));
 230
 231                 ddi_prop_remove_all(dip);
 232
 233                 return (DDI_SUCCESS);
 234                 /* NOTREACHED */
 235         case DDI_SUSPEND:
 236         case DDI_PM_SUSPEND:
 237                 return (DDI_SUCCESS);
 238                 /* NOTREACHED */
 239         default:
 240                 break;
 241         }
 242         return (DDI_FAILURE);
 243 }
 244
 245 /*ARGSUSED*/
 246 static int
 247 bpf_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
 248 {
 249         int error = DDI_FAILURE;
 250
 251         switch (infocmd) {
 252         case DDI_INFO_DEVT2DEVINFO:
 253                 *result = bpf_dev_info;
 254                 error = DDI_SUCCESS;
 255                 break;
 256         case DDI_INFO_DEVT2INSTANCE:
 257                 *result = NULL;
 258                 error = DDI_SUCCESS;
 259                 break;
 260         default:
 261                 break;
 262         }
 263         return (error);
 264 }
 265
 266 /*
 267  * The two functions below work with and manage a list of providers that
 268  * supply BPF with packets. Their addition and removal is only happens
 269  * when the bpf module is attaching/detaching, thus there is no race
 270  * condition to guard against with using locks as the kernel module system
 271  * takes care of this for us. Similarly, bpf_provider_tickle() is called
 272  * from bpf_setif, which implies an open file descriptor that would get
 273  * in the way of detach being active.
 274  */
 275 static int
 276 bpf_provider_add(bpf_provider_t *provider)
 277 {
 278         bpf_provider_list_t *bp;
 279
 280         LIST_FOREACH(bp, &bpf_providers, bpl_next) {
 281                 if (bp->bpl_what == provider)
 282                         return (EEXIST);
 283         }
 284
 285
 286         bp = kmem_alloc(sizeof (*bp), KM_SLEEP);
 287         bp->bpl_what = provider;
 288         LIST_INSERT_HEAD(&bpf_providers, bp, bpl_next);
 289
 290         return (0);
 291 }
 292
 293 static int
 294 bpf_provider_remove(bpf_provider_t *provider)
 295 {
 296         bpf_provider_list_t *bp;
 297
 298         LIST_FOREACH(bp, &bpf_providers, bpl_next) {
 299                 if (bp->bpl_what == provider)
 300                         break;
 301         }
 302
 303         if (bp == NULL)
 304                 return (ESRCH);
 305
 306         LIST_REMOVE(bp, bpl_next);
 307
 308         kmem_free(bp, sizeof (*bp));
 309
 310         return (0);
 311 }
 312
 313 /*
 314  * return a pointer to the structure that holds all of the functions
 315  * available to be used to support a particular packet provider.
 316  */
 317 bpf_provider_t *
 318 bpf_find_provider_by_id(int who)
 319 {
 320         bpf_provider_list_t *b;
 321
 322         LIST_FOREACH(b, &bpf_providers, bpl_next) {
 323                 if (b->bpl_what->bpr_unit == who)
 324                         return (b->bpl_what);
 325         }
 326
 327         return (NULL);
 328 }
 329
 330 /*
 331  * This function is used by bpf_setif() to force an open() to be called on
 332  * a given device name. If a device has been unloaded by the kernel, but it
 333  * is still recognised, then calling this function will hopefully cause it
 334  * to be loaded back into the kernel. When this function is called, it is
 335  * not known which packet provider the name belongs to so all are tried.
 336  */
 337 int
 338 bpf_provider_tickle(char *name, zoneid_t zone)
 339 {
 340         bpf_provider_list_t *bp;
 341         uintptr_t handle;
 342         int tickled = 0;
 343
 344         LIST_FOREACH(bp, &bpf_providers, bpl_next) {
 345                 handle = 0;
 346                 if (bp->bpl_what->bpr_open(name, &handle, zone) == 0) {
 347                         bp->bpl_what->bpr_close(handle);
 348                         tickled++;
 349                 } else if (bp->bpl_what->bpr_unit == BPR_MAC) {
 350                         /*
 351                          * For mac devices, sometimes the open/close is not
 352                          * enough. In that case, further provocation is
 353                          * attempted by fetching the linkid and trying to
 354                          * use that as the key for open, rather than the
 355                          * name.
 356                          */
 357                         datalink_id_t id;
 358
 359                         if (bp->bpl_what->bpr_getlinkid(name, &id,
 360                             zone) == 0) {
 361                                 if (bp->bpl_what->bpr_open(name, &handle,
 362                                     zone) == 0) {
 363                                         bp->bpl_what->bpr_close(handle);
 364                                         tickled++;
 365                                 } else {
 366                                         mac_handle_t mh;
 367
 368                                         if (mac_open_by_linkid(id, &mh) == 0) {
 369                                                 mac_close(mh);
 370                                                 tickled++;
 371                                         }
 372                                 }
 373                         }
 374                 }
 375
 376         }
 377
 378         if (tickled != 0)
 379                 return (EWOULDBLOCK);
 380
 381         return (ENXIO);
 382 }
 383
 384 /*
 385  * The following three functions provide the necessary callbacks into
 386  * the netinfo API. This API is primarily used to trigger awareness of
 387  * when a zone is being torn down, allowing BPF to drive IPNET to
 388  * tell it which interfaces need to go away.
 389  */
 390 /*ARGSUSED*/
 391 static void *
 392 bpf_create_inst(const netid_t netid)
 393 {
 394         /*
 395          * BPF does not keep any per-instance state, its list of
 396          * interfaces is global, as is its device hash table.
 397          */
 398         return ((void *)bpf_itap);
 399 }
 400
 401 /*ARGSUSED*/
 402 static void
 403 bpf_shutdown_inst(const netid_t netid, void *arg)
 404 {
 405 }
 406
 407 /*ARGSUSED*/
 408 static void
 409 bpf_destroy_inst(const netid_t netid, void *arg)
 410 {
 411 }