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 (struct bus_ops *)0 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 = (void *)0; 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 } 412