1 /* $KAME: qop_jobs.c,v 1.2 2002/10/26 07:09:22 kjc Exp $ */ 2 /* 3 * Copyright (c) 2001-2002, by the Rector and Board of Visitors of 4 * the University of Virginia. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, 8 * with or without modification, are permitted provided 9 * that the following conditions are met: 10 * 11 * Redistributions of source code must retain the above 12 * copyright notice, this list of conditions and the following 13 * disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer in the documentation and/or other materials provided 18 * with the distribution. 19 * 20 * Neither the name of the University of Virginia nor the names 21 * of its contributors may be used to endorse or promote products 22 * derived from this software without specific prior written 23 * permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 26 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 27 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 28 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 29 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE 30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 31 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 32 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 33 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 36 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 37 * THE POSSIBILITY OF SUCH DAMAGE. 38 */ 39 /* 40 * Copyright (C) 1999-2000 41 * Sony Computer Science Laboratories, Inc. All rights reserved. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 52 * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND 53 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 54 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 55 * ARE DISCLAIMED. IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE 56 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 57 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 58 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 59 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 60 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 61 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 62 * SUCH DAMAGE. 63 */ 64 /* 65 * JoBS - altq prototype implementation 66 * 67 * Author: Nicolas Christin <nicolas@cs.virginia.edu> 68 * 69 * JoBS algorithms originally devised and proposed by 70 * Nicolas Christin and Jorg Liebeherr. 71 * Grateful Acknowledgments to Tarek Abdelzaher for his help and 72 * comments, and to Kenjiro Cho for some helpful advice. 73 * Contributed by the Multimedia Networks Group at the University 74 * of Virginia. 75 * 76 * http://qosbox.cs.virginia.edu 77 * 78 */ 79 80 #include <sys/param.h> 81 #include <sys/socket.h> 82 #include <sys/sockio.h> 83 #include <sys/ioctl.h> 84 #include <sys/fcntl.h> 85 #include <net/if.h> 86 #include <netinet/in.h> 87 #include <arpa/inet.h> 88 89 #include <stdio.h> 90 #include <stdlib.h> 91 #include <unistd.h> 92 #include <stddef.h> 93 #include <string.h> 94 #include <ctype.h> 95 #include <errno.h> 96 #include <syslog.h> 97 #include <netdb.h> 98 99 #include <altq/altq.h> 100 #include <altq/altq_var.h> 101 #include <altq/altq_jobs.h> 102 #include "altq_qop.h" 103 #include "qop_jobs.h" 104 #define SCALE_LOSS 32 105 106 #if 0 107 static int qop_jobs_enable_hook(struct ifinfo *); 108 #endif 109 static int qop_jobs_delete_class_hook(struct classinfo *); 110 111 static int jobs_attach(struct ifinfo *); 112 static int jobs_detach(struct ifinfo *); 113 static int jobs_clear(struct ifinfo *); 114 static int jobs_enable(struct ifinfo *); 115 static int jobs_disable(struct ifinfo *); 116 static int jobs_add_class(struct classinfo *); 117 static int jobs_modify_class(struct classinfo *, void *); 118 static int jobs_delete_class(struct classinfo *); 119 static int jobs_add_filter(struct fltrinfo *); 120 static int jobs_delete_filter(struct fltrinfo *); 121 122 #define JOBS_DEVICE "/dev/altq/jobs" 123 124 static int jobs_fd = -1; 125 static int jobs_refcount = 0; 126 127 static struct qdisc_ops jobs_qdisc = { 128 ALTQT_JOBS, 129 "jobs", 130 jobs_attach, 131 jobs_detach, 132 jobs_clear, 133 jobs_enable, 134 jobs_disable, 135 jobs_add_class, 136 jobs_modify_class, 137 jobs_delete_class, 138 jobs_add_filter, 139 jobs_delete_filter 140 }; 141 142 /* 143 * parser interface 144 */ 145 #define EQUAL(s1, s2) (strcmp((s1), (s2)) == 0) 146 147 int 148 jobs_interface_parser(const char *ifname, int argc, char **argv) 149 { 150 u_int bandwidth = 100000000; /* 100 Mbps */ 151 u_int tbrsize = 0; 152 int qlimit = 200; /* 200 packets */ 153 int separate = 0; /* by default: shared buffer */ 154 155 /* 156 * process options 157 */ 158 while (argc > 0) { 159 if (EQUAL(*argv, "bandwidth")) { 160 argc--; argv++; 161 if (argc > 0) 162 bandwidth = atobps(*argv); 163 } else if (EQUAL(*argv, "tbrsize")) { 164 argc--; argv++; 165 if (argc > 0) 166 tbrsize = atobytes(*argv); 167 } else if (EQUAL(*argv, "qlimit")) { 168 argc--; argv++; 169 if (argc > 0) 170 qlimit = (int)strtol(*argv, NULL, 0); 171 } else if (EQUAL(*argv, "separate")) { 172 argc--; argv++; 173 separate = 1; 174 } else if (EQUAL(*argv, "jobs")) { 175 /* just skip */ 176 } else { 177 LOG(LOG_ERR, 0, "Unknown keyword '%s'", *argv); 178 return (0); 179 } 180 argc--; argv++; 181 } 182 183 if (qcmd_tbr_register(ifname, bandwidth, tbrsize) != 0) 184 return (0); 185 186 if (qcmd_jobs_add_if(ifname, bandwidth, qlimit, separate) != 0) 187 return (0); 188 return (1); 189 } 190 191 int 192 jobs_class_parser(const char *ifname, const char *class_name, 193 const char *parent_name, int argc, char **argv) 194 { 195 int64_t adc, rdc, alc, rlc, arc; 196 int pri = 0; 197 int flags = 0; 198 int error; 199 200 /* disable everything by default */ 201 adc = -1; 202 rdc = -1; 203 arc = -1; 204 alc = -1; 205 rlc = -1; 206 207 while (argc > 0) { 208 if (EQUAL(*argv, "priority")) { 209 argc--; argv++; 210 if (argc > 0) { 211 if (strtol(*argv, NULL, 0) < 0) 212 pri = 0; 213 else 214 pri = strtol(*argv, NULL, 0); 215 } 216 } else if (EQUAL(*argv, "adc")) { 217 argc--; argv++; 218 if (argc > 0) { 219 if (strtol(*argv, NULL, 0) < 0) 220 adc = -1; 221 else 222 adc = strtol(*argv, NULL, 0); 223 } 224 } else if (EQUAL(*argv, "rdc")) { 225 argc--; argv++; 226 if (argc > 0) { 227 if (strtol(*argv, NULL, 0) < 0) 228 rdc = -1; 229 else 230 rdc = strtol(*argv, NULL, 0); 231 } 232 } else if (EQUAL(*argv, "alc")) { 233 argc--; argv++; 234 if (argc > 0) { 235 if (strtol(*argv, NULL, 0) < 0) 236 alc = -1; 237 else 238 alc = (int64_t)(strtod(*argv, NULL) 239 * ((int64_t)1 << SCALE_LOSS)); 240 /* 241 * alc is given in fraction of 1, convert it 242 * to a fraction of 2^(SCALE_LOSS) 243 */ 244 } 245 } else if (EQUAL(*argv, "rlc")) { 246 argc--; argv++; 247 if (argc > 0) { 248 if (strtol(*argv, NULL, 0) < 0) 249 rlc = -1; 250 else 251 rlc = strtol(*argv, NULL, 0); 252 } 253 } else if (EQUAL(*argv, "arc")) { 254 argc--; argv++; 255 if (argc > 0) { 256 if (EQUAL(*argv,"-1")) 257 arc = -1; 258 else 259 arc = atobps(*argv); 260 } 261 } else if (EQUAL(*argv, "default")) { 262 flags |= JOCF_DEFAULTCLASS; 263 } else { 264 LOG(LOG_ERR, 0, 265 "Unknown keyword '%s' in %s, line %d", 266 *argv, altqconfigfile, line_no); 267 return (0); 268 } 269 argc--; argv++; 270 } 271 272 error = qcmd_jobs_add_class(ifname, class_name, pri, 273 adc, rdc, alc, rlc, arc, flags); 274 275 if (error) { 276 LOG(LOG_ERR, errno, "jobs_class_parser: %s", 277 qoperror(error)); 278 return (0); 279 } 280 return (1); 281 } 282 283 /* 284 * qcmd api 285 */ 286 int 287 qcmd_jobs_add_if(const char *ifname, u_int bandwidth, int qlimit, int separate) 288 { 289 int error; 290 291 error = qop_jobs_add_if(NULL, ifname, bandwidth, qlimit, separate); 292 if (error != 0) 293 LOG(LOG_ERR, errno, "%s: can't add jobs on interface '%s'", 294 qoperror(error), ifname); 295 return (error); 296 } 297 298 int 299 qcmd_jobs_add_class(const char *ifname, const char *class_name, int pri, 300 int64_t adc, int64_t rdc, int64_t alc, int64_t rlc, int64_t arc, 301 int flags) 302 { 303 struct ifinfo *ifinfo; 304 int error = 0; 305 char name_adc[20],name_alc[20],name_rdc[20],name_rlc[20],name_arc[20]; 306 307 if ((ifinfo = ifname2ifinfo(ifname)) == NULL) 308 error = QOPERR_BADIF; 309 if (error == 0) 310 error = qop_jobs_add_class(NULL, class_name, ifinfo, 311 pri, adc, rdc, alc, rlc, arc, flags); 312 if (error != 0) 313 LOG(LOG_ERR, errno, 314 "jobs: %s: can't add class '%s' on interface '%s'", 315 qoperror(error), class_name, ifname); 316 else { 317 if (adc > 0) 318 sprintf(name_adc,"%.3f ms",(double)adc/1000.); 319 else 320 sprintf(name_adc,"N/A"); 321 if (alc > 0) 322 sprintf(name_alc,"%.2f%%", 323 (double)100*alc/((u_int64_t)1 << SCALE_LOSS)); 324 else 325 sprintf(name_alc,"N/A"); 326 if (rdc > 0) 327 sprintf(name_rdc,"%d",(int)rdc); 328 else 329 sprintf(name_rdc,"N/A"); 330 if (rlc > 0) 331 sprintf(name_rlc,"%d",(int)rlc); 332 else 333 sprintf(name_rlc,"N/A"); 334 if (arc > 0) 335 sprintf(name_arc,"%.2f Mbps",(double)arc/1000000.); 336 else 337 sprintf(name_arc,"N/A"); 338 339 LOG(LOG_INFO, 0, 340 "added '%s' (pri=%d,adc=%s,rdc=%s,alc=%s,rlc=%s,arc=%s) on interface '%s'\n", 341 class_name,pri,name_adc,name_rdc,name_alc,name_rlc,name_arc,ifname); 342 } 343 return (error); 344 } 345 346 int 347 qcmd_jobs_modify_class(const char *ifname, const char *class_name, int pri, 348 int64_t adc, int64_t rdc, int64_t alc, int64_t rlc, int64_t arc) 349 { 350 struct ifinfo *ifinfo; 351 struct classinfo *clinfo; 352 353 if ((ifinfo = ifname2ifinfo(ifname)) == NULL) 354 return (QOPERR_BADIF); 355 356 if ((clinfo = clname2clinfo(ifinfo, class_name)) == NULL) 357 return (QOPERR_BADCLASS); 358 359 return qop_jobs_modify_class(clinfo, pri, adc, rdc, alc, rlc, arc); 360 } 361 362 /* 363 * qop api 364 */ 365 int 366 qop_jobs_add_if(struct ifinfo **rp, const char *ifname, 367 u_int bandwidth, int qlimit, int separate) 368 { 369 struct ifinfo *ifinfo = NULL; 370 struct jobs_ifinfo *jobs_ifinfo; 371 int error; 372 373 if ((jobs_ifinfo = calloc(1, sizeof(*jobs_ifinfo))) == NULL) 374 return (QOPERR_NOMEM); 375 jobs_ifinfo->qlimit = qlimit; 376 jobs_ifinfo->separate = separate; 377 378 error = qop_add_if(&ifinfo, ifname, bandwidth, 379 &jobs_qdisc, jobs_ifinfo); 380 if (error != 0) { 381 free(jobs_ifinfo); 382 return (error); 383 } 384 385 if (rp != NULL) 386 *rp = ifinfo; 387 return (0); 388 } 389 390 int 391 qop_jobs_add_class(struct classinfo **rp, const char *class_name, 392 struct ifinfo *ifinfo, int pri, 393 int64_t adc, int64_t rdc, int64_t alc, int64_t rlc, int64_t arc, 394 int flags) 395 { 396 struct classinfo *clinfo; 397 struct jobs_ifinfo *jobs_ifinfo; 398 struct jobs_classinfo *jobs_clinfo = NULL; 399 int error; 400 401 jobs_ifinfo = ifinfo->private; 402 if ((flags & JOCF_DEFAULTCLASS) && jobs_ifinfo->default_class != NULL) 403 return (QOPERR_CLASS_INVAL); 404 405 if ((jobs_clinfo = calloc(1, sizeof(*jobs_clinfo))) == NULL) { 406 error = QOPERR_NOMEM; 407 goto err_ret; 408 } 409 410 jobs_clinfo->pri = pri; 411 jobs_clinfo->adc = adc; 412 jobs_clinfo->rdc = rdc; 413 jobs_clinfo->alc = alc; 414 jobs_clinfo->rlc = rlc; 415 jobs_clinfo->arc = arc; 416 jobs_clinfo->flags = flags; 417 418 if ((error = qop_add_class(&clinfo, class_name, ifinfo, NULL, 419 jobs_clinfo)) != 0) 420 goto err_ret; 421 422 /* set delete hook */ 423 clinfo->delete_hook = qop_jobs_delete_class_hook; 424 425 if (flags & JOCF_DEFAULTCLASS) 426 jobs_ifinfo->default_class = clinfo; 427 428 if (rp != NULL) 429 *rp = clinfo; 430 return (0); 431 432 err_ret: 433 if (jobs_clinfo != NULL) { 434 free(jobs_clinfo); 435 clinfo->private = NULL; 436 } 437 438 return (error); 439 } 440 441 /* 442 * this is called from qop_delete_class() before a class is destroyed 443 * for discipline specific cleanup. 444 */ 445 static int 446 qop_jobs_delete_class_hook(struct classinfo *clinfo) 447 { 448 /* in fact this function doesn't do anything 449 * i'm not sure how/when it's used, so I just 450 * leave it here 451 */ 452 struct jobs_classinfo *jobs_clinfo; 453 454 jobs_clinfo = clinfo->private; 455 return (0); 456 } 457 458 int 459 qop_jobs_modify_class(struct classinfo *clinfo, int pri, 460 int64_t adc, int64_t rdc, int64_t alc, int64_t rlc, int64_t arc) 461 { 462 struct jobs_classinfo *jobs_clinfo = clinfo->private; 463 int error; 464 int pri_old; 465 int64_t adc_old, rdc_old, alc_old, rlc_old, arc_old; 466 467 pri_old = jobs_clinfo->pri; 468 adc_old = jobs_clinfo->adc; 469 rdc_old = jobs_clinfo->rdc; 470 alc_old = jobs_clinfo->alc; 471 rlc_old = jobs_clinfo->rlc; 472 arc_old = jobs_clinfo->arc; 473 474 jobs_clinfo = clinfo->private; 475 jobs_clinfo->adc = adc; 476 jobs_clinfo->rdc = rdc; 477 jobs_clinfo->alc = alc; 478 jobs_clinfo->rlc = rlc; 479 jobs_clinfo->arc = arc; 480 jobs_clinfo->pri = pri; 481 482 error = qop_modify_class(clinfo, NULL); 483 if (error == 0) 484 return (0); 485 486 /* modify failed!, restore the old service guarantees */ 487 jobs_clinfo->adc = adc_old; 488 jobs_clinfo->rdc = rdc_old; 489 jobs_clinfo->alc = alc_old; 490 jobs_clinfo->rlc = rlc_old; 491 jobs_clinfo->arc = arc_old; 492 jobs_clinfo->pri = pri_old; 493 return (error); 494 } 495 496 #if 0 497 /* 498 * sanity check at enabling jobs: 499 * there must one default class for an interface 500 */ 501 static int 502 qop_jobs_enable_hook(struct ifinfo *ifinfo) 503 { 504 struct jobs_ifinfo *jobs_ifinfo; 505 506 jobs_ifinfo = ifinfo->private; 507 if (jobs_ifinfo->default_class == NULL) { 508 LOG(LOG_ERR, 0, "jobs: no default class on interface %s!", 509 ifinfo->ifname); 510 return (QOPERR_CLASS); 511 } 512 return (0); 513 } 514 #endif 515 516 /* 517 * system call interfaces for qdisc_ops 518 */ 519 static int 520 jobs_attach(struct ifinfo *ifinfo) 521 { 522 struct jobs_attach attach; 523 524 if (jobs_fd < 0 && 525 (jobs_fd = open(JOBS_DEVICE, O_RDWR)) < 0 && 526 (jobs_fd = open_module(JOBS_DEVICE, O_RDWR)) < 0) { 527 LOG(LOG_ERR, errno, "JOBS open"); 528 return (QOPERR_SYSCALL); 529 } 530 531 jobs_refcount++; 532 memset(&attach, 0, sizeof(attach)); 533 strncpy(attach.iface.jobs_ifname, ifinfo->ifname, IFNAMSIZ); 534 attach.bandwidth = ifinfo->bandwidth; 535 attach.qlimit = (u_int)((struct jobs_ifinfo*)ifinfo->private)->qlimit; 536 attach.separate = (u_int)((struct jobs_ifinfo*)ifinfo->private)->separate; 537 538 if (ioctl(jobs_fd, JOBS_IF_ATTACH, (struct jobs_attach*) &attach) < 0) 539 return (QOPERR_SYSCALL); 540 541 #if 1 542 LOG(LOG_INFO, 0, 543 "jobs attached to %s (b/w = %d bps, buff = %d pkts [%s])\n", 544 attach.iface.jobs_ifname, 545 (int) attach.bandwidth, (int) attach.qlimit, 546 attach.separate?"separate buffers":"shared buffer"); 547 #endif 548 return (0); 549 } 550 551 static int 552 jobs_detach(struct ifinfo *ifinfo) 553 { 554 struct jobs_interface iface; 555 556 memset(&iface, 0, sizeof(iface)); 557 strncpy(iface.jobs_ifname, ifinfo->ifname, IFNAMSIZ); 558 559 if (ioctl(jobs_fd, JOBS_IF_DETACH, &iface) < 0) 560 return (QOPERR_SYSCALL); 561 562 if (--jobs_refcount == 0) { 563 close(jobs_fd); 564 jobs_fd = -1; 565 } 566 return (0); 567 } 568 569 static int 570 jobs_enable(struct ifinfo *ifinfo) 571 { 572 struct jobs_interface iface; 573 574 memset(&iface, 0, sizeof(iface)); 575 strncpy(iface.jobs_ifname, ifinfo->ifname, IFNAMSIZ); 576 577 if (ioctl(jobs_fd, JOBS_ENABLE, &iface) < 0) 578 return (QOPERR_SYSCALL); 579 return (0); 580 } 581 582 static int 583 jobs_disable(struct ifinfo *ifinfo) 584 { 585 struct jobs_interface iface; 586 587 memset(&iface, 0, sizeof(iface)); 588 strncpy(iface.jobs_ifname, ifinfo->ifname, IFNAMSIZ); 589 590 if (ioctl(jobs_fd, JOBS_DISABLE, &iface) < 0) 591 return (QOPERR_SYSCALL); 592 return (0); 593 } 594 595 static int 596 jobs_clear(struct ifinfo *ifinfo) 597 { 598 struct jobs_interface iface; 599 600 memset(&iface, 0, sizeof(iface)); 601 strncpy(iface.jobs_ifname, ifinfo->ifname, IFNAMSIZ); 602 603 if (ioctl(jobs_fd, JOBS_CLEAR, &iface) < 0) 604 return (QOPERR_SYSCALL); 605 return (0); 606 } 607 608 static int 609 jobs_add_class(struct classinfo *clinfo) 610 { 611 struct jobs_add_class class_add; 612 struct jobs_classinfo *jobs_clinfo; 613 struct jobs_ifinfo *jobs_ifinfo; 614 615 jobs_ifinfo = clinfo->ifinfo->private; 616 jobs_clinfo = clinfo->private; 617 618 memset(&class_add, 0, sizeof(class_add)); 619 strncpy(class_add.iface.jobs_ifname, clinfo->ifinfo->ifname, IFNAMSIZ); 620 class_add.pri = jobs_clinfo->pri; 621 class_add.cl_adc = jobs_clinfo->adc; 622 class_add.cl_rdc = jobs_clinfo->rdc; 623 class_add.cl_alc = jobs_clinfo->alc; 624 class_add.cl_rlc = jobs_clinfo->rlc; 625 class_add.cl_arc = jobs_clinfo->arc; 626 class_add.flags = jobs_clinfo->flags; 627 if (ioctl(jobs_fd, JOBS_ADD_CLASS, &class_add) < 0) { 628 clinfo->handle = JOBS_NULLCLASS_HANDLE; 629 return (QOPERR_SYSCALL); 630 } 631 clinfo->handle = class_add.class_handle; 632 return (0); 633 } 634 635 static int 636 jobs_modify_class(struct classinfo *clinfo, void *arg) 637 { 638 struct jobs_modify_class class_mod; 639 struct jobs_classinfo *jobs_clinfo; 640 641 jobs_clinfo = clinfo->private; 642 643 memset(&class_mod, 0, sizeof(class_mod)); 644 strncpy(class_mod.iface.jobs_ifname, clinfo->ifinfo->ifname, IFNAMSIZ); 645 class_mod.class_handle = clinfo->handle; 646 647 class_mod.pri = jobs_clinfo->pri; 648 class_mod.cl_adc = jobs_clinfo->adc; 649 class_mod.cl_rdc = jobs_clinfo->rdc; 650 class_mod.cl_alc = jobs_clinfo->alc; 651 class_mod.cl_rlc = jobs_clinfo->rlc; 652 class_mod.cl_arc = jobs_clinfo->arc; 653 class_mod.flags = jobs_clinfo->flags; 654 655 if (ioctl(jobs_fd, JOBS_MOD_CLASS, &class_mod) < 0) 656 return (QOPERR_SYSCALL); 657 return (0); 658 } 659 660 static int 661 jobs_delete_class(struct classinfo *clinfo) 662 { 663 struct jobs_delete_class class_delete; 664 665 if (clinfo->handle == JOBS_NULLCLASS_HANDLE) 666 return (0); 667 668 memset(&class_delete, 0, sizeof(class_delete)); 669 strncpy(class_delete.iface.jobs_ifname, clinfo->ifinfo->ifname, 670 IFNAMSIZ); 671 class_delete.class_handle = clinfo->handle; 672 673 if (ioctl(jobs_fd, JOBS_DEL_CLASS, &class_delete) < 0) 674 return (QOPERR_SYSCALL); 675 return (0); 676 } 677 678 static int 679 jobs_add_filter(struct fltrinfo *fltrinfo) 680 { 681 struct jobs_add_filter fltr_add; 682 683 memset(&fltr_add, 0, sizeof(fltr_add)); 684 strncpy(fltr_add.iface.jobs_ifname, fltrinfo->clinfo->ifinfo->ifname, 685 IFNAMSIZ); 686 fltr_add.class_handle = fltrinfo->clinfo->handle; 687 fltr_add.filter = fltrinfo->fltr; 688 689 if (ioctl(jobs_fd, JOBS_ADD_FILTER, &fltr_add) < 0) 690 return (QOPERR_SYSCALL); 691 fltrinfo->handle = fltr_add.filter_handle; 692 return (0); 693 } 694 695 static int 696 jobs_delete_filter(struct fltrinfo *fltrinfo) 697 { 698 struct jobs_delete_filter fltr_del; 699 700 memset(&fltr_del, 0, sizeof(fltr_del)); 701 strncpy(fltr_del.iface.jobs_ifname, fltrinfo->clinfo->ifinfo->ifname, 702 IFNAMSIZ); 703 fltr_del.filter_handle = fltrinfo->handle; 704 705 if (ioctl(jobs_fd, JOBS_DEL_FILTER, &fltr_del) < 0) 706 return (QOPERR_SYSCALL); 707 return (0); 708 } 709