1 /*- 2 * APM (Advanced Power Management) Event Dispatcher 3 * 4 * Copyright (c) 1999 Mitsuru IWASAKI <iwasaki@FreeBSD.org> 5 * Copyright (c) 1999 KOIE Hidetaka <koie@suri.co.jp> 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * 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 30 #ifndef lint 31 static const char rcsid[] = 32 "$FreeBSD$"; 33 #endif /* not lint */ 34 35 #include <assert.h> 36 #include <bitstring.h> 37 #include <err.h> 38 #include <errno.h> 39 #include <fcntl.h> 40 #include <paths.h> 41 #include <signal.h> 42 #include <stdio.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <syslog.h> 46 #include <unistd.h> 47 #include <sys/ioctl.h> 48 #include <sys/types.h> 49 #include <sys/time.h> 50 #include <sys/wait.h> 51 #include <machine/apm_bios.h> 52 53 #include "apmd.h" 54 55 int debug_level = 0; 56 int verbose = 0; 57 int soft_power_state_change = 0; 58 const char *apmd_configfile = APMD_CONFIGFILE; 59 const char *apmd_pidfile = APMD_PIDFILE; 60 int apmctl_fd = -1, apmnorm_fd = -1; 61 62 /* 63 * table of event handlers 64 */ 65 #define EVENT_CONFIG_INITIALIZER(EV,R) { #EV, NULL, R }, 66 struct event_config events[EVENT_MAX] = { 67 EVENT_CONFIG_INITIALIZER(NOEVENT, 0) 68 EVENT_CONFIG_INITIALIZER(STANDBYREQ, 1) 69 EVENT_CONFIG_INITIALIZER(SUSPENDREQ, 1) 70 EVENT_CONFIG_INITIALIZER(NORMRESUME, 0) 71 EVENT_CONFIG_INITIALIZER(CRITRESUME, 0) 72 EVENT_CONFIG_INITIALIZER(BATTERYLOW, 0) 73 EVENT_CONFIG_INITIALIZER(POWERSTATECHANGE, 0) 74 EVENT_CONFIG_INITIALIZER(UPDATETIME, 0) 75 EVENT_CONFIG_INITIALIZER(CRITSUSPEND, 1) 76 EVENT_CONFIG_INITIALIZER(USERSTANDBYREQ, 1) 77 EVENT_CONFIG_INITIALIZER(USERSUSPENDREQ, 1) 78 EVENT_CONFIG_INITIALIZER(STANDBYRESUME, 0) 79 EVENT_CONFIG_INITIALIZER(CAPABILITIESCHANGE, 0) 80 }; 81 82 /* 83 * List of battery events 84 */ 85 struct battery_watch_event *battery_watch_list = NULL; 86 87 #define BATT_CHK_INTV 10 /* how many seconds between battery state checks? */ 88 89 /* 90 * default procedure 91 */ 92 struct event_cmd * 93 event_cmd_default_clone(void *this) 94 { 95 struct event_cmd * oldone = this; 96 struct event_cmd * newone = malloc(oldone->len); 97 98 newone->next = NULL; 99 newone->len = oldone->len; 100 newone->name = oldone->name; 101 newone->op = oldone->op; 102 return newone; 103 } 104 105 /* 106 * exec command 107 */ 108 int 109 event_cmd_exec_act(void *this) 110 { 111 struct event_cmd_exec * p = this; 112 int status = -1; 113 pid_t pid; 114 115 switch ((pid = fork())) { 116 case -1: 117 warn("cannot fork"); 118 break; 119 case 0: 120 /* child process */ 121 signal(SIGHUP, SIG_DFL); 122 signal(SIGCHLD, SIG_DFL); 123 signal(SIGTERM, SIG_DFL); 124 execl(_PATH_BSHELL, "sh", "-c", p->line, (char *)NULL); 125 _exit(127); 126 default: 127 /* parent process */ 128 do { 129 pid = waitpid(pid, &status, 0); 130 } while (pid == -1 && errno == EINTR); 131 break; 132 } 133 return status; 134 } 135 void 136 event_cmd_exec_dump(void *this, FILE *fp) 137 { 138 fprintf(fp, " \"%s\"", ((struct event_cmd_exec *)this)->line); 139 } 140 struct event_cmd * 141 event_cmd_exec_clone(void *this) 142 { 143 struct event_cmd_exec * newone = (struct event_cmd_exec *) event_cmd_default_clone(this); 144 struct event_cmd_exec * oldone = this; 145 146 newone->evcmd.next = NULL; 147 newone->evcmd.len = oldone->evcmd.len; 148 newone->evcmd.name = oldone->evcmd.name; 149 newone->evcmd.op = oldone->evcmd.op; 150 if ((newone->line = strdup(oldone->line)) == NULL) 151 err(1, "out of memory"); 152 return (struct event_cmd *) newone; 153 } 154 void 155 event_cmd_exec_free(void *this) 156 { 157 free(((struct event_cmd_exec *)this)->line); 158 } 159 struct event_cmd_op event_cmd_exec_ops = { 160 event_cmd_exec_act, 161 event_cmd_exec_dump, 162 event_cmd_exec_clone, 163 event_cmd_exec_free 164 }; 165 166 /* 167 * reject command 168 */ 169 int 170 event_cmd_reject_act(void *this __unused) 171 { 172 int rc = 0; 173 174 if (ioctl(apmctl_fd, APMIO_REJECTLASTREQ, NULL)) { 175 syslog(LOG_NOTICE, "fail to reject\n"); 176 rc = -1; 177 } 178 return rc; 179 } 180 struct event_cmd_op event_cmd_reject_ops = { 181 event_cmd_reject_act, 182 NULL, 183 event_cmd_default_clone, 184 NULL 185 }; 186 187 /* 188 * manipulate event_config 189 */ 190 struct event_cmd * 191 clone_event_cmd_list(struct event_cmd *p) 192 { 193 struct event_cmd dummy; 194 struct event_cmd *q = &dummy; 195 for ( ;p; p = p->next) { 196 assert(p->op->clone); 197 if ((q->next = p->op->clone(p)) == NULL) 198 err(1, "out of memory"); 199 q = q->next; 200 } 201 q->next = NULL; 202 return dummy.next; 203 } 204 void 205 free_event_cmd_list(struct event_cmd *p) 206 { 207 struct event_cmd * q; 208 for ( ; p ; p = q) { 209 q = p->next; 210 if (p->op->free) 211 p->op->free(p); 212 free(p); 213 } 214 } 215 int 216 register_battery_handlers( 217 int level, int direction, 218 struct event_cmd *cmdlist) 219 { 220 /* 221 * level is negative if it's in "minutes", non-negative if 222 * percentage. 223 * 224 * direction =1 means we care about this level when charging, 225 * direction =-1 means we care about it when discharging. 226 */ 227 if (level>100) /* percentage > 100 */ 228 return -1; 229 if (abs(direction) != 1) /* nonsense direction value */ 230 return -1; 231 232 if (cmdlist) { 233 struct battery_watch_event *we; 234 235 if ((we = malloc(sizeof(struct battery_watch_event))) == NULL) 236 err(1, "out of memory"); 237 238 we->next = battery_watch_list; /* starts at NULL */ 239 battery_watch_list = we; 240 we->level = abs(level); 241 we->type = (level<0)?BATTERY_MINUTES:BATTERY_PERCENT; 242 we->direction = (direction<0)?BATTERY_DISCHARGING: 243 BATTERY_CHARGING; 244 we->done = 0; 245 we->cmdlist = clone_event_cmd_list(cmdlist); 246 } 247 return 0; 248 } 249 int 250 register_apm_event_handlers( 251 bitstr_t bit_decl(evlist, EVENT_MAX), 252 struct event_cmd *cmdlist) 253 { 254 if (cmdlist) { 255 bitstr_t bit_decl(tmp, EVENT_MAX); 256 memcpy(&tmp, evlist, bitstr_size(EVENT_MAX)); 257 258 for (;;) { 259 int n; 260 struct event_cmd *p; 261 struct event_cmd *q; 262 bit_ffs(tmp, EVENT_MAX, &n); 263 if (n < 0) 264 break; 265 p = events[n].cmdlist; 266 if ((q = clone_event_cmd_list(cmdlist)) == NULL) 267 err(1, "out of memory"); 268 if (p) { 269 while (p->next != NULL) 270 p = p->next; 271 p->next = q; 272 } else { 273 events[n].cmdlist = q; 274 } 275 bit_clear(tmp, n); 276 } 277 } 278 return 0; 279 } 280 281 /* 282 * execute command 283 */ 284 int 285 exec_run_cmd(struct event_cmd *p) 286 { 287 int status = 0; 288 289 for (; p; p = p->next) { 290 assert(p->op->act); 291 if (verbose) 292 syslog(LOG_INFO, "action: %s", p->name); 293 status = p->op->act(p); 294 if (status) { 295 syslog(LOG_NOTICE, "command finished with %d\n", status); 296 break; 297 } 298 } 299 return status; 300 } 301 302 /* 303 * execute command -- the event version 304 */ 305 int 306 exec_event_cmd(struct event_config *ev) 307 { 308 int status = 0; 309 310 status = exec_run_cmd(ev->cmdlist); 311 if (status && ev->rejectable) { 312 syslog(LOG_ERR, "canceled"); 313 event_cmd_reject_act(NULL); 314 } 315 return status; 316 } 317 318 /* 319 * read config file 320 */ 321 extern FILE * yyin; 322 extern int yydebug; 323 324 void 325 read_config(void) 326 { 327 int i; 328 329 if ((yyin = fopen(apmd_configfile, "r")) == NULL) { 330 err(1, "cannot open config file"); 331 } 332 333 #ifdef DEBUG 334 yydebug = debug_level; 335 #endif 336 337 if (yyparse() != 0) 338 err(1, "cannot parse config file"); 339 340 fclose(yyin); 341 342 /* enable events */ 343 for (i = 0; i < EVENT_MAX; i++) { 344 if (events[i].cmdlist) { 345 u_int event_type = i; 346 if (write(apmctl_fd, &event_type, sizeof(u_int)) == -1) { 347 err(1, "cannot enable event 0x%x", event_type); 348 } 349 } 350 } 351 } 352 353 void 354 dump_config(void) 355 { 356 int i; 357 struct battery_watch_event *q; 358 359 for (i = 0; i < EVENT_MAX; i++) { 360 struct event_cmd * p; 361 if ((p = events[i].cmdlist)) { 362 fprintf(stderr, "apm_event %s {\n", events[i].name); 363 for ( ; p ; p = p->next) { 364 fprintf(stderr, "\t%s", p->name); 365 if (p->op->dump) 366 p->op->dump(p, stderr); 367 fprintf(stderr, ";\n"); 368 } 369 fprintf(stderr, "}\n"); 370 } 371 } 372 for (q = battery_watch_list ; q != NULL ; q = q -> next) { 373 struct event_cmd * p; 374 fprintf(stderr, "apm_battery %d%s %s {\n", 375 q -> level, 376 (q -> type == BATTERY_PERCENT)?"%":"m", 377 (q -> direction == BATTERY_CHARGING)?"charging": 378 "discharging"); 379 for ( p = q -> cmdlist; p ; p = p->next) { 380 fprintf(stderr, "\t%s", p->name); 381 if (p->op->dump) 382 p->op->dump(p, stderr); 383 fprintf(stderr, ";\n"); 384 } 385 fprintf(stderr, "}\n"); 386 } 387 } 388 389 void 390 destroy_config(void) 391 { 392 int i; 393 struct battery_watch_event *q; 394 395 /* disable events */ 396 for (i = 0; i < EVENT_MAX; i++) { 397 if (events[i].cmdlist) { 398 u_int event_type = i; 399 if (write(apmctl_fd, &event_type, sizeof(u_int)) == -1) { 400 err(1, "cannot disable event 0x%x", event_type); 401 } 402 } 403 } 404 405 for (i = 0; i < EVENT_MAX; i++) { 406 struct event_cmd * p; 407 if ((p = events[i].cmdlist)) 408 free_event_cmd_list(p); 409 events[i].cmdlist = NULL; 410 } 411 412 for( ; battery_watch_list; battery_watch_list = battery_watch_list -> next) { 413 free_event_cmd_list(battery_watch_list->cmdlist); 414 q = battery_watch_list->next; 415 free(battery_watch_list); 416 battery_watch_list = q; 417 } 418 } 419 420 void 421 restart(void) 422 { 423 destroy_config(); 424 read_config(); 425 if (verbose) 426 dump_config(); 427 } 428 429 /* 430 * write pid file 431 */ 432 static void 433 write_pid(void) 434 { 435 FILE *fp = fopen(apmd_pidfile, "w"); 436 437 if (fp) { 438 fprintf(fp, "%ld\n", (long)getpid()); 439 fclose(fp); 440 } 441 } 442 443 /* 444 * handle signals 445 */ 446 static int signal_fd[2]; 447 448 void 449 enque_signal(int sig) 450 { 451 if (write(signal_fd[1], &sig, sizeof sig) != sizeof sig) 452 err(1, "cannot process signal."); 453 } 454 455 void 456 wait_child(void) 457 { 458 int status; 459 while (waitpid(-1, &status, WNOHANG) > 0) 460 ; 461 } 462 463 int 464 proc_signal(int fd) 465 { 466 int rc = 0; 467 int sig; 468 469 while (read(fd, &sig, sizeof sig) == sizeof sig) { 470 syslog(LOG_INFO, "caught signal: %d", sig); 471 switch (sig) { 472 case SIGHUP: 473 syslog(LOG_NOTICE, "restart by SIG"); 474 restart(); 475 break; 476 case SIGTERM: 477 syslog(LOG_NOTICE, "going down on signal %d", sig); 478 rc = -1; 479 return rc; 480 case SIGCHLD: 481 wait_child(); 482 break; 483 default: 484 warn("unexpected signal(%d) received.", sig); 485 break; 486 } 487 } 488 return rc; 489 } 490 void 491 proc_apmevent(int fd) 492 { 493 struct apm_event_info apmevent; 494 495 while (ioctl(fd, APMIO_NEXTEVENT, &apmevent) == 0) { 496 int status; 497 syslog(LOG_NOTICE, "apmevent %04x index %d\n", 498 apmevent.type, apmevent.index); 499 syslog(LOG_INFO, "apm event: %s", events[apmevent.type].name); 500 if (fork() == 0) { 501 status = exec_event_cmd(&events[apmevent.type]); 502 exit(status); 503 } 504 } 505 } 506 507 #define AC_POWER_STATE ((pw_info.ai_acline == 1) ? BATTERY_CHARGING :\ 508 BATTERY_DISCHARGING) 509 510 void 511 check_battery(void) 512 { 513 514 static int first_time=1, last_state; 515 int status; 516 517 struct apm_info pw_info; 518 struct battery_watch_event *p; 519 520 /* If we don't care, don't bother */ 521 if (battery_watch_list == NULL) 522 return; 523 524 if (first_time) { 525 if ( ioctl(apmnorm_fd, APMIO_GETINFO, &pw_info) < 0) 526 err(1, "cannot check battery state."); 527 /* 528 * This next statement isn't entirely true. The spec does not tie AC 529 * line state to battery charging or not, but this is a bit lazier to do. 530 */ 531 last_state = AC_POWER_STATE; 532 first_time = 0; 533 return; /* We can't process events, we have no baseline */ 534 } 535 536 /* 537 * XXX - should we do this a bunch of times and perform some sort 538 * of smoothing or correction? 539 */ 540 if ( ioctl(apmnorm_fd, APMIO_GETINFO, &pw_info) < 0) 541 err(1, "cannot check battery state."); 542 543 /* 544 * If we're not in the state now that we were in last time, 545 * then it's a transition, which means we must clean out 546 * the event-caught state. 547 */ 548 if (last_state != AC_POWER_STATE) { 549 if (soft_power_state_change && fork() == 0) { 550 status = exec_event_cmd(&events[PMEV_POWERSTATECHANGE]); 551 exit(status); 552 } 553 last_state = AC_POWER_STATE; 554 for (p = battery_watch_list ; p!=NULL ; p = p -> next) 555 p->done = 0; 556 } 557 for (p = battery_watch_list ; p != NULL ; p = p -> next) 558 if (p -> direction == AC_POWER_STATE && 559 !(p -> done) && 560 ((p -> type == BATTERY_PERCENT && 561 p -> level == (int)pw_info.ai_batt_life) || 562 (p -> type == BATTERY_MINUTES && 563 p -> level == (pw_info.ai_batt_time / 60)))) { 564 p -> done++; 565 if (verbose) 566 syslog(LOG_NOTICE, "Caught battery event: %s, %d%s", 567 (p -> direction == BATTERY_CHARGING)?"charging":"discharging", 568 p -> level, 569 (p -> type == BATTERY_PERCENT)?"%":" minutes"); 570 if (fork() == 0) { 571 status = exec_run_cmd(p -> cmdlist); 572 exit(status); 573 } 574 } 575 } 576 void 577 event_loop(void) 578 { 579 int fdmax = 0; 580 struct sigaction nsa; 581 fd_set master_rfds; 582 sigset_t sigmask, osigmask; 583 584 FD_ZERO(&master_rfds); 585 FD_SET(apmctl_fd, &master_rfds); 586 fdmax = apmctl_fd > fdmax ? apmctl_fd : fdmax; 587 588 FD_SET(signal_fd[0], &master_rfds); 589 fdmax = signal_fd[0] > fdmax ? signal_fd[0] : fdmax; 590 591 memset(&nsa, 0, sizeof nsa); 592 nsa.sa_handler = enque_signal; 593 sigfillset(&nsa.sa_mask); 594 nsa.sa_flags = SA_RESTART; 595 sigaction(SIGHUP, &nsa, NULL); 596 sigaction(SIGCHLD, &nsa, NULL); 597 sigaction(SIGTERM, &nsa, NULL); 598 599 sigemptyset(&sigmask); 600 sigaddset(&sigmask, SIGHUP); 601 sigaddset(&sigmask, SIGCHLD); 602 sigaddset(&sigmask, SIGTERM); 603 sigprocmask(SIG_SETMASK, &sigmask, &osigmask); 604 605 while (1) { 606 fd_set rfds; 607 int res; 608 struct timeval to; 609 610 to.tv_sec = BATT_CHK_INTV; 611 to.tv_usec = 0; 612 613 memcpy(&rfds, &master_rfds, sizeof rfds); 614 sigprocmask(SIG_SETMASK, &osigmask, NULL); 615 if ((res=select(fdmax + 1, &rfds, 0, 0, &to)) < 0) { 616 if (errno != EINTR) 617 err(1, "select"); 618 } 619 sigprocmask(SIG_SETMASK, &sigmask, NULL); 620 621 if (res == 0) { /* time to check the battery */ 622 check_battery(); 623 continue; 624 } 625 626 if (FD_ISSET(signal_fd[0], &rfds)) { 627 if (proc_signal(signal_fd[0]) < 0) 628 return; 629 } 630 631 if (FD_ISSET(apmctl_fd, &rfds)) 632 proc_apmevent(apmctl_fd); 633 } 634 } 635 636 int 637 main(int ac, char* av[]) 638 { 639 int ch; 640 int daemonize = 1; 641 char *prog; 642 int logopt = LOG_NDELAY | LOG_PID; 643 644 while ((ch = getopt(ac, av, "df:sv")) != -1) { 645 switch (ch) { 646 case 'd': 647 daemonize = 0; 648 debug_level++; 649 break; 650 case 'f': 651 apmd_configfile = optarg; 652 break; 653 case 's': 654 soft_power_state_change = 1; 655 break; 656 case 'v': 657 verbose = 1; 658 break; 659 default: 660 err(1, "unknown option `%c'", ch); 661 } 662 } 663 664 if (daemonize) 665 daemon(0, 0); 666 667 #ifdef NICE_INCR 668 nice(NICE_INCR); 669 #endif 670 671 if (!daemonize) 672 logopt |= LOG_PERROR; 673 674 prog = strrchr(av[0], '/'); 675 openlog(prog ? prog+1 : av[0], logopt, LOG_DAEMON); 676 677 syslog(LOG_NOTICE, "start"); 678 679 if (pipe(signal_fd) < 0) 680 err(1, "pipe"); 681 if (fcntl(signal_fd[0], F_SETFL, O_NONBLOCK) < 0) 682 err(1, "fcntl"); 683 684 if ((apmnorm_fd = open(APM_NORM_DEVICEFILE, O_RDWR)) == -1) { 685 err(1, "cannot open device file `%s'", APM_NORM_DEVICEFILE); 686 } 687 688 if (fcntl(apmnorm_fd, F_SETFD, 1) == -1) { 689 err(1, "cannot set close-on-exec flag for device file '%s'", APM_NORM_DEVICEFILE); 690 } 691 692 if ((apmctl_fd = open(APM_CTL_DEVICEFILE, O_RDWR)) == -1) { 693 err(1, "cannot open device file `%s'", APM_CTL_DEVICEFILE); 694 } 695 696 if (fcntl(apmctl_fd, F_SETFD, 1) == -1) { 697 err(1, "cannot set close-on-exec flag for device file '%s'", APM_CTL_DEVICEFILE); 698 } 699 700 restart(); 701 write_pid(); 702 event_loop(); 703 exit(EXIT_SUCCESS); 704 } 705 706