1 /* 2 * Copyright (c) 2005-2006 The FreeBSD Project 3 * All rights reserved. 4 * 5 * Author: Victor Cruceru <soc-victor@freebsd.org> 6 * 7 * Redistribution of this software and documentation and use in source and 8 * binary forms, with or without modification, are permitted provided that 9 * the following conditions are met: 10 * 11 * 1. Redistributions of source code or documentation must retain the above 12 * copyright notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 * 31 * Host Resources MIB for SNMPd. Implementation for hrSWRunTable 32 */ 33 34 #include <sys/param.h> 35 #include <sys/proc.h> 36 #include <sys/sysctl.h> 37 #include <sys/user.h> 38 #include <sys/linker.h> 39 40 #include <assert.h> 41 #include <signal.h> 42 #include <stdlib.h> 43 #include <string.h> 44 #include <syslog.h> 45 46 #include "hostres_snmp.h" 47 #include "hostres_oid.h" 48 #include "hostres_tree.h" 49 50 /* 51 * Ugly thing: PID_MAX, NO_PID defined only in kernel 52 */ 53 #define NO_PID 100000 54 55 enum SWRunType { 56 SRT_UNKNOWN = 1, 57 SRT_OPERATING_SYSTEM = 2, 58 SRT_DEVICE_DRIVER = 3, 59 SRT_APPLICATION = 4 60 61 }; 62 63 enum SWRunStatus { 64 SRS_RUNNING = 1, 65 SRS_RUNNABLE = 2, 66 SRS_NOT_RUNNABLE = 3, 67 SRS_INVALID = 4 68 }; 69 70 /* Maximum lengths for the strings according to the MIB */ 71 #define SWR_NAME_MLEN (64 + 1) 72 #define SWR_PATH_MLEN (128 + 1) 73 #define SWR_PARAM_MLEN (128 + 1) 74 75 /* 76 * This structure is used to hold a SNMP table entry 77 * for both hrSWRunTable and hrSWRunPerfTable because 78 * hrSWRunPerfTable AUGMENTS hrSWRunTable 79 */ 80 struct swrun_entry { 81 int32_t index; 82 u_char *name; /* it may be NULL */ 83 const struct asn_oid *id; 84 u_char *path; /* it may be NULL */ 85 u_char *parameters; /* it may be NULL */ 86 int32_t type; /* enum SWRunType */ 87 int32_t status; /* enum SWRunStatus */ 88 int32_t perfCPU; 89 int32_t perfMemory; 90 #define HR_SWRUN_FOUND 0x001 91 uint32_t flags; 92 uint64_t r_tick; /* tick when entry refreshed */ 93 TAILQ_ENTRY(swrun_entry) link; 94 }; 95 TAILQ_HEAD(swrun_tbl, swrun_entry); 96 97 /* the head of the list with hrSWRunTable's entries */ 98 static struct swrun_tbl swrun_tbl = TAILQ_HEAD_INITIALIZER(swrun_tbl); 99 100 /* last (agent) tick when hrSWRunTable and hrSWRunPerTable was updated */ 101 static uint64_t swrun_tick; 102 103 /* maximum number of ticks between updates of SWRun and SWRunPerf table */ 104 uint32_t swrun_tbl_refresh = HR_SWRUN_TBL_REFRESH * 100; 105 106 /* the value of the MIB object with the same name */ 107 static int32_t SWOSIndex; 108 109 /** 110 * Malloc a new entry and add it to the list 111 * associated to this table. The item identified by 112 * the index parameter must not exist in this list. 113 */ 114 static struct swrun_entry * 115 swrun_entry_create(int32_t idx) 116 { 117 struct swrun_entry *entry; 118 119 if ((entry = malloc(sizeof(*entry))) == NULL) { 120 syslog(LOG_WARNING, "%s: %m", __func__); 121 return (NULL); 122 } 123 memset(entry, 0, sizeof(*entry)); 124 entry->index = idx; 125 126 INSERT_OBJECT_INT(entry, &swrun_tbl); 127 return (entry); 128 } 129 130 /** 131 * Unlink the entry from the list and then free its heap memory 132 */ 133 static void 134 swrun_entry_delete(struct swrun_entry *entry) 135 { 136 137 assert(entry != NULL); 138 139 TAILQ_REMOVE(&swrun_tbl, entry, link); 140 141 free(entry->name); 142 free(entry->path); 143 free(entry->parameters); 144 free(entry); 145 } 146 147 /** 148 * Search one item by its index, return NULL if none found 149 */ 150 static struct swrun_entry * 151 swrun_entry_find_by_index(int32_t idx) 152 { 153 struct swrun_entry *entry; 154 155 TAILQ_FOREACH(entry, &swrun_tbl, link) 156 if (entry->index == idx) 157 return (entry); 158 return (NULL); 159 } 160 161 /** 162 * Translate the kernel's process status to SNMP. 163 */ 164 static enum SWRunStatus 165 swrun_OS_get_proc_status(const struct kinfo_proc *kp) 166 { 167 168 assert(kp != NULL); 169 if(kp == NULL) { 170 return (SRS_INVALID); 171 } 172 173 /* 174 * I'm using the old style flags - they look cleaner to me, 175 * at least for the purpose of this SNMP table 176 */ 177 switch (kp->ki_stat) { 178 179 case SSTOP: 180 return (SRS_NOT_RUNNABLE); 181 182 case SWAIT: 183 case SLOCK: 184 case SSLEEP: 185 return (SRS_RUNNABLE); 186 187 case SZOMB: 188 return (SRS_INVALID); 189 190 case SIDL: 191 case SRUN: 192 return (SRS_RUNNING); 193 194 default: 195 syslog(LOG_ERR,"Unknown process state: %d", kp->ki_stat); 196 return (SRS_INVALID); 197 } 198 } 199 200 /** 201 * Make an SNMP table entry from a kernel one. 202 */ 203 static void 204 kinfo_proc_to_swrun_entry(const struct kinfo_proc *kp, 205 struct swrun_entry *entry) 206 { 207 char **argv = NULL; 208 uint64_t cpu_time = 0; 209 size_t pname_len; 210 211 pname_len = strlen(kp->ki_comm) + 1; 212 entry->name = reallocf(entry->name, pname_len); 213 if (entry->name != NULL) 214 strlcpy(entry->name, kp->ki_comm, pname_len); 215 216 entry->id = &oid_zeroDotZero; /* unknown id - FIXME */ 217 218 assert(hr_kd != NULL); 219 220 argv = kvm_getargv(hr_kd, kp, SWR_PARAM_MLEN - 1); 221 if(argv != NULL){ 222 u_char param[SWR_PARAM_MLEN]; 223 224 memset(param, '\0', sizeof(param)); 225 226 /* 227 * FIXME 228 * Path seems to not be available. 229 * Try to hack the info in argv[0]; 230 * this argv is under control of the program so this info 231 * is not realiable 232 */ 233 if(*argv != NULL && (*argv)[0] == '/') { 234 size_t path_len; 235 236 path_len = strlen(*argv) + 1; 237 if (path_len > SWR_PATH_MLEN) 238 path_len = SWR_PATH_MLEN; 239 240 entry->path = reallocf(entry->path, path_len); 241 if (entry->path != NULL) { 242 memset(entry->path, '\0', path_len); 243 strlcpy((char*)entry->path, *argv, path_len); 244 } 245 } 246 247 argv++; /* skip the first one which was used for path */ 248 249 while (argv != NULL && *argv != NULL ) { 250 if (param[0] != 0) { 251 /* 252 * add a space between parameters, 253 * except before the first one 254 */ 255 strlcat((char *)param, " ", sizeof(param)); 256 } 257 strlcat((char *)param, *argv, sizeof(param)); 258 argv++; 259 } 260 /* reuse pname_len */ 261 pname_len = strlen(param) + 1; 262 if (pname_len > SWR_PARAM_MLEN) 263 pname_len = SWR_PARAM_MLEN; 264 265 entry->parameters = reallocf(entry->parameters, pname_len); 266 strlcpy(entry->parameters, param, pname_len); 267 } 268 269 entry->type = (int32_t)(IS_KERNPROC(kp) ? SRT_OPERATING_SYSTEM : 270 SRT_APPLICATION); 271 272 entry->status = (int32_t)swrun_OS_get_proc_status(kp); 273 cpu_time = kp->ki_runtime / 100000; /* centi-seconds */ 274 275 /* may overflow the snmp type */ 276 entry->perfCPU = (cpu_time > (uint64_t)INT_MAX ? INT_MAX : cpu_time); 277 entry->perfMemory = kp->ki_size / 1024; /* in kilo-bytes */ 278 entry->r_tick = get_ticks(); 279 } 280 281 /** 282 * Create a table entry for a KLD 283 */ 284 static void 285 kld_file_stat_to_swrun(const struct kld_file_stat *kfs, 286 struct swrun_entry *entry) 287 { 288 size_t name_len; 289 290 assert(kfs != NULL); 291 assert(entry != NULL); 292 293 name_len = strlen(kfs->name) + 1; 294 if (name_len > SWR_NAME_MLEN) 295 name_len = SWR_NAME_MLEN; 296 297 entry->name = reallocf(entry->name, name_len); 298 if (entry->name != NULL) 299 strlcpy((char *)entry->name, kfs->name, name_len); 300 301 /* FIXME: can we find the location where the module was loaded from? */ 302 entry->path = NULL; 303 304 /* no parameters for kernel files (.ko) of for the kernel */ 305 entry->parameters = NULL; 306 307 entry->id = &oid_zeroDotZero; /* unknown id - FIXME */ 308 309 if (strcmp(kfs->name, "kernel") == 0) { 310 entry->type = (int32_t)SRT_OPERATING_SYSTEM; 311 SWOSIndex = entry->index; 312 } else { 313 entry->type = (int32_t)SRT_DEVICE_DRIVER; /* well, not really */ 314 } 315 entry->status = (int32_t)SRS_RUNNING; 316 entry->perfCPU = 0; /* Info not available */ 317 entry->perfMemory = kfs->size / 1024; /* in kilo-bytes */ 318 entry->r_tick = get_ticks(); 319 } 320 321 /** 322 * Get all visible processes including the kernel visible threads 323 */ 324 static void 325 swrun_OS_get_procs(void) 326 { 327 struct kinfo_proc *plist, *kp; 328 int i; 329 int nproc; 330 struct swrun_entry *entry; 331 332 plist = kvm_getprocs(hr_kd, KERN_PROC_ALL, 0, &nproc); 333 if (plist == NULL || nproc < 0) { 334 syslog(LOG_ERR, "kvm_getprocs() failed: %m"); 335 return; 336 } 337 for (i = 0, kp = plist; i < nproc; i++, kp++) { 338 /* 339 * The SNMP table's index must begin from 1 (as specified by 340 * this table definition), the PIDs are starting from 0 341 * so we are translating the PIDs to +1 342 */ 343 entry = swrun_entry_find_by_index((int32_t)kp->ki_pid + 1); 344 if (entry == NULL) { 345 /* new entry - get memory for it */ 346 entry = swrun_entry_create((int32_t)kp->ki_pid + 1); 347 if (entry == NULL) 348 continue; 349 } 350 entry->flags |= HR_SWRUN_FOUND; /* mark it as found */ 351 352 kinfo_proc_to_swrun_entry(kp, entry); 353 } 354 } 355 356 /* 357 * Get kernel items: first the kernel itself, then the loaded modules. 358 */ 359 static void 360 swrun_OS_get_kinfo(void) 361 { 362 int fileid; 363 struct swrun_entry *entry; 364 struct kld_file_stat stat; 365 366 for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { 367 stat.version = sizeof(struct kld_file_stat); 368 if (kldstat(fileid, &stat) < 0) { 369 syslog(LOG_ERR, "kldstat() failed: %m"); 370 continue; 371 } 372 373 /* 374 * kernel and kernel files (*.ko) will be indexed starting with 375 * NO_PID + 1; NO_PID is PID_MAX + 1 thus it will be no risk to 376 * overlap with real PIDs which are in range of 1 .. NO_PID 377 */ 378 entry = swrun_entry_find_by_index(NO_PID + 1 + stat.id); 379 if (entry == NULL) { 380 /* new entry - get memory for it */ 381 entry = swrun_entry_create(NO_PID + 1 + stat.id); 382 if (entry == NULL) 383 continue; 384 } 385 entry->flags |= HR_SWRUN_FOUND; /* mark it as found */ 386 387 kld_file_stat_to_swrun(&stat, entry); 388 } 389 } 390 391 /** 392 * Refresh the hrSWRun and hrSWRunPert tables. 393 */ 394 static void 395 refresh_swrun_tbl(void) 396 { 397 398 struct swrun_entry *entry, *entry_tmp; 399 400 if (this_tick - swrun_tick < swrun_tbl_refresh) { 401 HRDBG("no refresh needed "); 402 return; 403 } 404 405 /* mark each entry as missing */ 406 TAILQ_FOREACH(entry, &swrun_tbl, link) 407 entry->flags &= ~HR_SWRUN_FOUND; 408 409 swrun_OS_get_procs(); 410 swrun_OS_get_kinfo(); 411 412 /* 413 * Purge items that disappeared 414 */ 415 TAILQ_FOREACH_SAFE(entry, &swrun_tbl, link, entry_tmp) 416 if (!(entry->flags & HR_SWRUN_FOUND)) 417 swrun_entry_delete(entry); 418 419 swrun_tick = this_tick; 420 421 HRDBG("refresh DONE"); 422 } 423 424 /** 425 * Update the information in this entry 426 */ 427 static void 428 fetch_swrun_entry(struct swrun_entry *entry) 429 { 430 struct kinfo_proc *plist; 431 int nproc; 432 struct kld_file_stat stat; 433 434 assert(entry != NULL); 435 436 if (entry->index >= NO_PID + 1) { 437 /* 438 * kernel and kernel files (*.ko) will be indexed 439 * starting with NO_PID + 1; NO_PID is PID_MAX + 1 440 * thus it will be no risk to overlap with real PIDs 441 * which are in range of 1 .. NO_PID 442 */ 443 stat.version = sizeof(stat); 444 if (kldstat(entry->index - NO_PID - 1, &stat) == -1) { 445 /* 446 * not found, it's gone. Mark it as invalid for now, it 447 * will be removed from the list at next global refersh 448 */ 449 HRDBG("missing item with kid=%d", 450 entry->index - NO_PID - 1); 451 entry->status = (int32_t)SRS_INVALID; 452 } else 453 kld_file_stat_to_swrun(&stat, entry); 454 455 } else { 456 /* this is a process */ 457 assert(hr_kd != NULL); 458 plist = kvm_getprocs(hr_kd, KERN_PROC_PID, 459 entry->index - 1, &nproc); 460 if (plist == NULL || nproc != 1) { 461 HRDBG("missing item with PID=%d", entry->index - 1); 462 entry->status = (int32_t)SRS_INVALID; 463 } else 464 kinfo_proc_to_swrun_entry(plist, entry); 465 } 466 } 467 468 /** 469 * Invalidate entry. For KLDs we try to unload it, for processes we SIGKILL it. 470 */ 471 static int 472 invalidate_swrun_entry(struct swrun_entry *entry, int commit) 473 { 474 struct kinfo_proc *plist; 475 int nproc; 476 struct kld_file_stat stat; 477 478 assert(entry != NULL); 479 480 if (entry->index >= NO_PID + 1) { 481 /* this is a kernel item */ 482 HRDBG("attempt to unload KLD %d", 483 entry->index - NO_PID - 1); 484 485 if (entry->index == SWOSIndex) { 486 /* can't invalidate the kernel itself */ 487 return (SNMP_ERR_NOT_WRITEABLE); 488 } 489 490 stat.version = sizeof(stat); 491 if (kldstat(entry->index - NO_PID - 1, &stat) == -1) { 492 /* 493 * not found, it's gone. Mark it as invalid for now, it 494 * will be removed from the list at next global 495 * refresh 496 */ 497 HRDBG("missing item with kid=%d", 498 entry->index - NO_PID - 1); 499 entry->status = (int32_t)SRS_INVALID; 500 return (SNMP_ERR_NOERROR); 501 } 502 /* 503 * There is no way to try to unload a module. There seems 504 * also no way to find out whether it is busy without unloading 505 * it. We can assume that it is busy, if the reference count 506 * is larger than 2, but if it is 1 nothing helps. 507 */ 508 if (!commit) { 509 if (stat.refs > 1) 510 return (SNMP_ERR_NOT_WRITEABLE); 511 return (SNMP_ERR_NOERROR); 512 } 513 if (kldunload(stat.id) == -1) { 514 syslog(LOG_ERR,"kldunload for %d/%s failed: %m", 515 stat.id, stat.name); 516 if (errno == EBUSY) 517 return (SNMP_ERR_NOT_WRITEABLE); 518 else 519 return (SNMP_ERR_RES_UNAVAIL); 520 } 521 } else { 522 /* this is a process */ 523 assert(hr_kd != NULL); 524 525 plist = kvm_getprocs(hr_kd, KERN_PROC_PID, 526 entry->index - 1, &nproc); 527 if (plist == NULL || nproc != 1) { 528 HRDBG("missing item with PID=%d", entry->index - 1); 529 entry->status = (int32_t)SRS_INVALID; 530 return (SNMP_ERR_NOERROR); 531 } 532 if (IS_KERNPROC(plist)) { 533 /* you don't want to do this */ 534 return (SNMP_ERR_NOT_WRITEABLE); 535 } 536 if (kill(entry->index - 1, commit ? SIGKILL : 0) < 0) { 537 syslog(LOG_ERR,"kill (%d, SIGKILL) failed: %m", 538 entry->index - 1); 539 if (errno == ESRCH) { 540 /* race: just gone */ 541 entry->status = (int32_t)SRS_INVALID; 542 return (SNMP_ERR_NOERROR); 543 } 544 return (SNMP_ERR_GENERR); 545 } 546 } 547 return (SNMP_ERR_NOERROR); 548 } 549 550 /** 551 * Popuplate the hrSWRunTable. 552 */ 553 void 554 init_swrun_tbl(void) 555 { 556 557 refresh_swrun_tbl(); 558 HRDBG("done"); 559 } 560 561 /** 562 * Finalize the hrSWRunTable. 563 */ 564 void 565 fini_swrun_tbl(void) 566 { 567 struct swrun_entry *n1; 568 569 while ((n1 = TAILQ_FIRST(&swrun_tbl)) != NULL) { 570 TAILQ_REMOVE(&swrun_tbl, n1, link); 571 free(n1); 572 } 573 } 574 575 /* 576 * This is the implementation for a generated (by a SNMP tool) 577 * function prototype, see hostres_tree.h 578 * It hanldes the SNMP operations for hrSWRunTable 579 */ 580 int 581 op_hrSWRunTable(struct snmp_context *ctx __unused, struct snmp_value *value, 582 u_int sub, u_int iidx __unused, enum snmp_op curr_op) 583 { 584 struct swrun_entry *entry; 585 int ret; 586 587 refresh_swrun_tbl(); 588 589 switch (curr_op) { 590 591 case SNMP_OP_GETNEXT: 592 if ((entry = NEXT_OBJECT_INT(&swrun_tbl, 593 &value->var, sub)) == NULL) 594 return (SNMP_ERR_NOSUCHNAME); 595 value->var.len = sub + 1; 596 value->var.subs[sub] = entry->index; 597 goto get; 598 599 case SNMP_OP_GET: 600 if ((entry = FIND_OBJECT_INT(&swrun_tbl, 601 &value->var, sub)) == NULL) 602 return (SNMP_ERR_NOSUCHNAME); 603 goto get; 604 605 case SNMP_OP_SET: 606 if ((entry = FIND_OBJECT_INT(&swrun_tbl, 607 &value->var, sub)) == NULL) 608 return (SNMP_ERR_NO_CREATION); 609 610 if (entry->r_tick < this_tick) 611 fetch_swrun_entry(entry); 612 613 switch (value->var.subs[sub - 1]) { 614 615 case LEAF_hrSWRunStatus: 616 if (value->v.integer != (int32_t)SRS_INVALID) 617 return (SNMP_ERR_WRONG_VALUE); 618 619 if (entry->status == (int32_t)SRS_INVALID) 620 return (SNMP_ERR_NOERROR); 621 622 /* 623 * Here we have a problem with the entire SNMP 624 * model: if we kill now, we cannot rollback. 625 * If we kill in the commit code, we cannot 626 * return an error. Because things may change between 627 * SET and COMMIT this is impossible to handle 628 * correctly. 629 */ 630 return (invalidate_swrun_entry(entry, 0)); 631 } 632 return (SNMP_ERR_NOT_WRITEABLE); 633 634 case SNMP_OP_ROLLBACK: 635 return (SNMP_ERR_NOERROR); 636 637 case SNMP_OP_COMMIT: 638 if ((entry = FIND_OBJECT_INT(&swrun_tbl, 639 &value->var, sub)) == NULL) 640 return (SNMP_ERR_NOERROR); 641 642 switch (value->var.subs[sub - 1]) { 643 644 case LEAF_hrSWRunStatus: 645 if (value->v.integer == (int32_t)SRS_INVALID && 646 entry->status != (int32_t)SRS_INVALID) 647 (void)invalidate_swrun_entry(entry, 1); 648 return (SNMP_ERR_NOERROR); 649 } 650 abort(); 651 } 652 abort(); 653 654 get: 655 ret = SNMP_ERR_NOERROR; 656 switch (value->var.subs[sub - 1]) { 657 658 case LEAF_hrSWRunIndex: 659 value->v.integer = entry->index; 660 break; 661 662 case LEAF_hrSWRunName: 663 if (entry->name != NULL) 664 ret = string_get(value, entry->name, -1); 665 else 666 ret = string_get(value, "", -1); 667 break; 668 669 case LEAF_hrSWRunID: 670 assert(entry->id != NULL); 671 value->v.oid = *entry->id; 672 break; 673 674 case LEAF_hrSWRunPath: 675 if (entry->path != NULL) 676 ret = string_get(value, entry->path, -1); 677 else 678 ret = string_get(value, "", -1); 679 break; 680 681 case LEAF_hrSWRunParameters: 682 if (entry->parameters != NULL) 683 ret = string_get(value, entry->parameters, -1); 684 else 685 ret = string_get(value, "", -1); 686 break; 687 688 case LEAF_hrSWRunType: 689 value->v.integer = entry->type; 690 break; 691 692 case LEAF_hrSWRunStatus: 693 value->v.integer = entry->status; 694 break; 695 696 default: 697 abort(); 698 } 699 return (ret); 700 } 701 702 /** 703 * Scalar(s) in the SWRun group 704 */ 705 int 706 op_hrSWRun(struct snmp_context *ctx __unused, struct snmp_value *value, 707 u_int sub, u_int iidx __unused, enum snmp_op curr_op) 708 { 709 710 /* only SNMP GET is possible */ 711 switch (curr_op) { 712 713 case SNMP_OP_GET: 714 goto get; 715 716 case SNMP_OP_SET: 717 return (SNMP_ERR_NOT_WRITEABLE); 718 719 case SNMP_OP_ROLLBACK: 720 case SNMP_OP_COMMIT: 721 case SNMP_OP_GETNEXT: 722 abort(); 723 } 724 abort(); 725 726 get: 727 switch (value->var.subs[sub - 1]) { 728 729 case LEAF_hrSWOSIndex: 730 value->v.uint32 = SWOSIndex; 731 return (SNMP_ERR_NOERROR); 732 733 default: 734 abort(); 735 } 736 } 737 738 /* 739 * This is the implementation for a generated (by a SNMP tool) 740 * function prototype, see hostres_tree.h 741 * It handles the SNMP operations for hrSWRunPerfTable 742 */ 743 int 744 op_hrSWRunPerfTable(struct snmp_context *ctx __unused, 745 struct snmp_value *value, u_int sub, u_int iidx __unused, 746 enum snmp_op curr_op ) 747 { 748 struct swrun_entry *entry; 749 750 refresh_swrun_tbl(); 751 752 switch (curr_op) { 753 754 case SNMP_OP_GETNEXT: 755 if ((entry = NEXT_OBJECT_INT(&swrun_tbl, 756 &value->var, sub)) == NULL) 757 return (SNMP_ERR_NOSUCHNAME); 758 value->var.len = sub + 1; 759 value->var.subs[sub] = entry->index; 760 goto get; 761 762 case SNMP_OP_GET: 763 if ((entry = FIND_OBJECT_INT(&swrun_tbl, 764 &value->var, sub)) == NULL) 765 return (SNMP_ERR_NOSUCHNAME); 766 goto get; 767 768 case SNMP_OP_SET: 769 if ((entry = FIND_OBJECT_INT(&swrun_tbl, 770 &value->var, sub)) == NULL) 771 return (SNMP_ERR_NO_CREATION); 772 return (SNMP_ERR_NOT_WRITEABLE); 773 774 case SNMP_OP_ROLLBACK: 775 case SNMP_OP_COMMIT: 776 abort(); 777 } 778 abort(); 779 780 get: 781 switch (value->var.subs[sub - 1]) { 782 783 case LEAF_hrSWRunPerfCPU: 784 value->v.integer = entry->perfCPU; 785 return (SNMP_ERR_NOERROR); 786 787 case LEAF_hrSWRunPerfMem: 788 value->v.integer = entry->perfMemory; 789 return (SNMP_ERR_NOERROR); 790 } 791 abort(); 792 } 793