dbus/controller.c

   1 /* -*- Mode: C ; c-basic-offset: 4 -*- */
   2 /*
   3     Copyright (C) 2007-2024 Nedko Arnaudov
   4     Copyright (C) 2007-2008 Juuso Alasuutari
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #if defined(HAVE_CONFIG_H)
  22 #include "config.h"
  23 #endif
  24
  25 #include <stdint.h>
  26 #include <string.h>
  27 #include <dbus/dbus.h>
  28 #include <assert.h>
  29 #include <unistd.h>
  30 #include <sys/sysinfo.h>
  31 #include <errno.h>
  32
  33 #include "controller.h"
  34 #include "controller_internal.h"
  35 #include "xml.h"
  36 #include "device_reservation.h"
  37
  38 struct jack_dbus_interface_descriptor * g_jackcontroller_interfaces[] =
  39 {
  40     &g_jack_controller_iface_introspectable,
  41     &g_jack_controller_iface_control,
  42     &g_jack_controller_iface_configure,
  43     &g_jack_controller_iface_patchbay,
  44     &g_jack_controller_iface_session_manager,
  45     &g_jack_controller_iface_transport,
  46     NULL
  47 };
  48
  49 static
  50 jackctl_driver_t *
  51 jack_controller_find_driver(
  52     jackctl_server_t *server,
  53     const char *driver_name)
  54 {
  55     const JSList * node_ptr;
  56
  57     node_ptr = jackctl_server_get_drivers_list(server);
  58
  59     while (node_ptr)
  60     {
  61         if (strcmp(jackctl_driver_get_name((jackctl_driver_t *)node_ptr->data), driver_name) == 0)
  62         {
  63             return node_ptr->data;
  64         }
  65
  66         node_ptr = jack_slist_next(node_ptr);
  67     }
  68
  69     return NULL;
  70 }
  71
  72 static bool jack_controller_check_slave_driver(struct jack_controller * controller_ptr, const char * name)
  73 {
  74     struct list_head * node_ptr;
  75     struct jack_controller_slave_driver * driver_ptr;
  76
  77     list_for_each(node_ptr, &controller_ptr->slave_drivers)
  78     {
  79         driver_ptr = list_entry(node_ptr, struct jack_controller_slave_driver, siblings);
  80         if (strcmp(name, driver_ptr->name) == 0)
  81         {
  82             return true;
  83         }
  84     }
  85
  86     return false;
  87 }
  88
  89 static bool jack_controller_load_slave_drivers(struct jack_controller * controller_ptr)
  90 {
  91     struct list_head * node_ptr;
  92     struct jack_controller_slave_driver * driver_ptr;
  93
  94     list_for_each(node_ptr, &controller_ptr->slave_drivers)
  95     {
  96         driver_ptr = list_entry(node_ptr, struct jack_controller_slave_driver, siblings);
  97
  98         assert(driver_ptr->handle != NULL);
  99         assert(!driver_ptr->loaded);
 100
 101         if (!jackctl_server_add_slave(controller_ptr->server, driver_ptr->handle))
 102         {
 103             jack_error("Driver \"%s\" cannot be loaded", driver_ptr->name);
 104             return false;
 105         }
 106
 107         driver_ptr->loaded = true;
 108     }
 109
 110     return true;
 111 }
 112
 113 static void jack_controller_unload_slave_drivers(struct jack_controller * controller_ptr)
 114 {
 115     struct list_head * node_ptr;
 116     struct jack_controller_slave_driver * driver_ptr;
 117
 118     list_for_each(node_ptr, &controller_ptr->slave_drivers)
 119     {
 120         driver_ptr = list_entry(node_ptr, struct jack_controller_slave_driver, siblings);
 121         if (driver_ptr->loaded)
 122         {
 123             jackctl_server_remove_slave(controller_ptr->server, driver_ptr->handle);
 124             driver_ptr->loaded = false;
 125         }
 126     }
 127 }
 128
 129 static void jack_controller_remove_slave_drivers(struct jack_controller * controller_ptr)
 130 {
 131     struct jack_controller_slave_driver * driver_ptr;
 132
 133     while (!list_empty(&controller_ptr->slave_drivers))
 134     {
 135         driver_ptr = list_entry(controller_ptr->slave_drivers.next, struct jack_controller_slave_driver, siblings);
 136         assert(!driver_ptr->loaded);
 137         list_del(&driver_ptr->siblings);
 138         free(driver_ptr->name);
 139         free(driver_ptr);
 140     }
 141
 142     controller_ptr->slave_drivers_vparam_value.str[0] = 0;
 143 }
 144
 145 static
 146 jackctl_internal_t *
 147 jack_controller_find_internal(
 148     jackctl_server_t *server,
 149     const char *internal_name)
 150 {
 151     const JSList * node_ptr;
 152
 153     node_ptr = jackctl_server_get_internals_list(server);
 154
 155     while (node_ptr)
 156     {
 157         if (strcmp(jackctl_internal_get_name((jackctl_internal_t *)node_ptr->data), internal_name) == 0)
 158         {
 159             return node_ptr->data;
 160         }
 161
 162         node_ptr = jack_slist_next(node_ptr);
 163     }
 164
 165     return NULL;
 166 }
 167
 168 bool
 169 jack_controller_select_driver(
 170     struct jack_controller * controller_ptr,
 171     const char * driver_name)
 172 {
 173     if (!jack_params_set_driver(controller_ptr->params, driver_name))
 174     {
 175         return false;
 176     }
 177
 178     jack_info("driver \"%s\" selected", driver_name);
 179
 180     return true;
 181 }
 182
 183 static
 184 int
 185 jack_controller_xrun(void * arg)
 186 {
 187         ((struct jack_controller *)arg)->xruns++;
 188
 189         return 0;
 190 }
 191
 192 bool
 193 jack_controller_start_server(
 194     struct jack_controller * controller_ptr,
 195     void *dbus_call_context_ptr)
 196 {
 197     int ret;
 198
 199     jack_info("Starting jack server...");
 200
 201     assert(!controller_ptr->started); /* should be ensured by caller */
 202
 203     controller_ptr->xruns = 0;
 204
 205     if (!jackctl_server_open(
 206             controller_ptr->server,
 207             jack_params_get_driver(controller_ptr->params)))
 208     {
 209         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to open server");
 210         goto fail;
 211     }
 212
 213     jack_controller_load_slave_drivers(controller_ptr);
 214
 215     if (!jackctl_server_start(
 216             controller_ptr->server))
 217     {
 218         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to start server");
 219         goto fail_close_server;
 220     }
 221
 222     controller_ptr->client = jack_client_open(
 223         "dbusapi",
 224         JackNoStartServer,
 225         NULL);
 226     if (controller_ptr->client == NULL)
 227     {
 228         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to create dbusapi jack client");
 229         goto fail_stop_server;
 230     }
 231
 232     ret = jack_set_xrun_callback(controller_ptr->client, jack_controller_xrun, controller_ptr);
 233     if (ret != 0)
 234     {
 235         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to set xrun callback. error is %d", ret);
 236         goto fail_close_client;
 237     }
 238
 239     if (!jack_controller_patchbay_init(controller_ptr))
 240     {
 241         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to initialize patchbay district");
 242         goto fail_close_client;
 243     }
 244
 245     ret = jack_activate(controller_ptr->client);
 246     if (ret != 0)
 247     {
 248         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "failed to activate dbusapi jack client. error is %d", ret);
 249         goto fail_patchbay_uninit;
 250     }
 251
 252     controller_ptr->started = true;
 253
 254     return TRUE;
 255
 256 fail_patchbay_uninit:
 257     jack_controller_patchbay_uninit(controller_ptr);
 258
 259 fail_close_client:
 260     ret = jack_client_close(controller_ptr->client);
 261     if (ret != 0)
 262     {
 263         jack_error("jack_client_close() failed with error %d", ret);
 264     }
 265
 266     controller_ptr->client = NULL;
 267
 268 fail_stop_server:
 269     if (!jackctl_server_stop(controller_ptr->server))
 270     {
 271         jack_error("failed to stop jack server");
 272     }
 273
 274 fail_close_server:
 275     jack_controller_unload_slave_drivers(controller_ptr);
 276
 277     if (!jackctl_server_close(controller_ptr->server))
 278     {
 279         jack_error("failed to close jack server");
 280     }
 281
 282 fail:
 283     return FALSE;
 284 }
 285
 286 bool
 287 jack_controller_stop_server(
 288     struct jack_controller * controller_ptr,
 289     void *dbus_call_context_ptr)
 290 {
 291     int ret;
 292
 293     pthread_mutex_lock(&controller_ptr->lock);
 294     if (!list_empty(&controller_ptr->session_pending_commands))
 295     {
 296         pthread_mutex_unlock(&controller_ptr->lock);
 297         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Refusing to stop JACK server because of pending session commands");
 298         return false;
 299     }
 300     pthread_mutex_unlock(&controller_ptr->lock);
 301
 302     jack_info("Stopping jack server...");
 303
 304     assert(controller_ptr->started); /* should be ensured by caller */
 305
 306     ret = jack_deactivate(controller_ptr->client);
 307     if (ret != 0)
 308     {
 309         jack_error("failed to deactivate dbusapi jack client. error is %d", ret);
 310     }
 311
 312     jack_controller_patchbay_uninit(controller_ptr);
 313
 314     ret = jack_client_close(controller_ptr->client);
 315     if (ret != 0)
 316     {
 317         jack_error("jack_client_close() failed with error %d", ret);
 318     }
 319
 320     controller_ptr->client = NULL;
 321
 322     if (!jackctl_server_stop(controller_ptr->server))
 323     {
 324         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to stop server");
 325         return FALSE;
 326     }
 327
 328     jack_controller_unload_slave_drivers(controller_ptr);
 329
 330     if (!jackctl_server_close(controller_ptr->server))
 331     {
 332         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to close server");
 333         return FALSE;
 334     }
 335
 336     controller_ptr->started = false;
 337
 338     return TRUE;
 339 }
 340
 341 bool
 342 jack_controller_switch_master(
 343     struct jack_controller * controller_ptr,
 344     void *dbus_call_context_ptr)
 345 {
 346     assert(controller_ptr->started); /* should be ensured by caller */
 347
 348     if (!jackctl_server_switch_master(
 349             controller_ptr->server,
 350             jack_params_get_driver(controller_ptr->params)))
 351     {
 352         jack_dbus_error(dbus_call_context_ptr, JACK_DBUS_ERROR_GENERIC, "Failed to switch master");
 353         controller_ptr->started = false;
 354         return FALSE;
 355     }
 356
 357     return TRUE;
 358 }
 359
 360 #define controller_ptr ((struct jack_controller *)obj)
 361
 362 static bool slave_drivers_parameter_is_set(void * obj)
 363 {
 364     return controller_ptr->slave_drivers_set;
 365 }
 366
 367 static bool slave_drivers_parameter_reset(void * obj)
 368 {
 369     if (controller_ptr->started)
 370     {
 371         jack_error("Cannot modify slave-drivers when server is started");
 372         return false;
 373     }
 374
 375     jack_controller_remove_slave_drivers(controller_ptr);
 376     controller_ptr->slave_drivers_set = false;
 377     return true;
 378 }
 379
 380 static union jackctl_parameter_value slave_drivers_parameter_get_value(void * obj)
 381 {
 382     return controller_ptr->slave_drivers_vparam_value;
 383 }
 384
 385 static bool slave_drivers_parameter_set_value(void * obj, const union jackctl_parameter_value * value_ptr)
 386 {
 387     char * buffer;
 388     char * save;
 389     const char * token;
 390     struct list_head old_list;
 391     struct list_head new_list;
 392     union jackctl_parameter_value old_value;
 393     union jackctl_parameter_value new_value;
 394     bool old_set;
 395
 396     if (controller_ptr->started)
 397     {
 398         jack_error("Cannot modify slave-drivers when server is started");
 399         return false;
 400     }
 401
 402     old_set = controller_ptr->slave_drivers_set;
 403     old_value = controller_ptr->slave_drivers_vparam_value;
 404     controller_ptr->slave_drivers_vparam_value.str[0] = 0;
 405     old_list = controller_ptr->slave_drivers;
 406     INIT_LIST_HEAD(&controller_ptr->slave_drivers);
 407
 408     buffer = strdup(value_ptr->str);
 409     if (buffer == NULL)
 410     {
 411         jack_error("strdup() failed.");
 412         return false;
 413     }
 414
 415     token = strtok_r(buffer, ",", &save);
 416     while (token)
 417     {
 418         //jack_info("slave driver '%s'", token);
 419         if (!jack_controller_add_slave_driver(controller_ptr, token))
 420         {
 421             jack_controller_remove_slave_drivers(controller_ptr);
 422             controller_ptr->slave_drivers = old_list;
 423             controller_ptr->slave_drivers_vparam_value = old_value;
 424             controller_ptr->slave_drivers_set = old_set;
 425
 426             free(buffer);
 427
 428             return false;
 429         }
 430
 431         token = strtok_r(NULL, ",", &save);
 432     }
 433
 434     new_value = controller_ptr->slave_drivers_vparam_value;
 435     new_list = controller_ptr->slave_drivers;
 436     controller_ptr->slave_drivers = old_list;
 437     jack_controller_remove_slave_drivers(controller_ptr);
 438     controller_ptr->slave_drivers_vparam_value = new_value;
 439     controller_ptr->slave_drivers = new_list;
 440     controller_ptr->slave_drivers_set = true;
 441
 442     free(buffer);
 443
 444     return true;
 445 }
 446
 447 static union jackctl_parameter_value slave_drivers_parameter_get_default_value(void * obj)
 448 {
 449     union jackctl_parameter_value value;
 450     value.str[0] = 0;
 451     return value;
 452 }
 453
 454 #undef controller_ptr
 455
 456 void *
 457 jack_controller_create(
 458         DBusConnection *connection)
 459 {
 460     int error;
 461     struct jack_controller *controller_ptr;
 462     const char * address[PARAM_ADDRESS_SIZE];
 463     DBusObjectPathVTable vtable =
 464     {
 465         jack_dbus_message_handler_unregister,
 466         jack_dbus_message_handler,
 467         NULL
 468     };
 469
 470     controller_ptr = malloc(sizeof(struct jack_controller));
 471     if (!controller_ptr)
 472     {
 473         jack_error("Ran out of memory trying to allocate struct jack_controller");
 474         goto fail;
 475     }
 476
 477     error = pthread_mutex_init(&controller_ptr->lock, NULL);
 478     if (error != 0)
 479     {
 480         jack_error("Failed to initialize mutex. error %d", error);
 481         goto fail_free;
 482     }
 483
 484     INIT_LIST_HEAD(&controller_ptr->session_pending_commands);
 485
 486     controller_ptr->server = jackctl_server_create(
 487         device_reservation_acquire,
 488         device_reservation_release);
 489     if (controller_ptr->server == NULL)
 490     {
 491         jack_error("Failed to create server object");
 492         goto fail_uninit_mutex;
 493     }
 494
 495     controller_ptr->params = jack_params_create(controller_ptr->server);
 496     if (controller_ptr->params == NULL)
 497     {
 498         jack_error("Failed to initialize parameter tree");
 499         goto fail_destroy_server;
 500     }
 501
 502     controller_ptr->client = NULL;
 503     controller_ptr->started = false;
 504
 505     controller_ptr->pending_save = 0;
 506
 507     INIT_LIST_HEAD(&controller_ptr->slave_drivers);
 508     controller_ptr->slave_drivers_set = false;
 509     controller_ptr->slave_drivers_vparam_value.str[0] = 0;
 510
 511     controller_ptr->slave_drivers_vparam.obj = controller_ptr;
 512
 513     controller_ptr->slave_drivers_vparam.vtable.is_set = slave_drivers_parameter_is_set;
 514     controller_ptr->slave_drivers_vparam.vtable.reset = slave_drivers_parameter_reset;
 515     controller_ptr->slave_drivers_vparam.vtable.get_value = slave_drivers_parameter_get_value;
 516     controller_ptr->slave_drivers_vparam.vtable.set_value = slave_drivers_parameter_set_value;
 517     controller_ptr->slave_drivers_vparam.vtable.get_default_value = slave_drivers_parameter_get_default_value;
 518
 519     controller_ptr->slave_drivers_vparam.type = JackParamString;
 520     controller_ptr->slave_drivers_vparam.name = "slave-drivers";
 521     controller_ptr->slave_drivers_vparam.short_decr = "Slave drivers to use";
 522     controller_ptr->slave_drivers_vparam.long_descr = "A comma separated list of slave drivers";
 523     controller_ptr->slave_drivers_vparam.constraint_flags = 0;
 524
 525     address[0] = PTNODE_ENGINE;
 526     address[1] = NULL;
 527     jack_params_add_parameter(controller_ptr->params, address, true, &controller_ptr->slave_drivers_vparam);
 528
 529     controller_ptr->dbus_descriptor.context = controller_ptr;
 530     controller_ptr->dbus_descriptor.interfaces = g_jackcontroller_interfaces;
 531
 532     if (!dbus_connection_register_object_path(
 533             connection,
 534             JACK_CONTROLLER_OBJECT_PATH,
 535             &vtable,
 536             &controller_ptr->dbus_descriptor))
 537     {
 538         jack_error("Ran out of memory trying to register D-Bus object path");
 539         goto fail_destroy_params;
 540     }
 541
 542     jack_controller_settings_load(controller_ptr);
 543
 544     return controller_ptr;
 545
 546 fail_destroy_params:
 547     jack_params_destroy(controller_ptr->params);
 548
 549 fail_destroy_server:
 550     jackctl_server_destroy(controller_ptr->server);
 551
 552 fail_uninit_mutex:
 553     pthread_mutex_destroy(&controller_ptr->lock);
 554
 555 fail_free:
 556     free(controller_ptr);
 557
 558 fail:
 559     return NULL;
 560 }
 561
 562 bool
 563 jack_controller_add_slave_driver(
 564     struct jack_controller * controller_ptr,
 565     const char * driver_name)
 566 {
 567     jackctl_driver_t * driver;
 568     struct jack_controller_slave_driver * driver_ptr;
 569     size_t len_old;
 570     size_t len_new;
 571
 572     len_old = strlen(controller_ptr->slave_drivers_vparam_value.str);
 573     len_new = strlen(driver_name);
 574     if (len_old + len_new + 2 > sizeof(controller_ptr->slave_drivers_vparam_value.str))
 575     {
 576         jack_error("No more space for slave drivers.");
 577         return false;
 578     }
 579
 580     driver = jack_controller_find_driver(controller_ptr->server, driver_name);
 581     if (driver == NULL)
 582     {
 583         jack_error("Unknown driver \"%s\"", driver_name);
 584         return false;
 585     }
 586
 587     if (jack_controller_check_slave_driver(controller_ptr, driver_name))
 588     {
 589         jack_info("Driver \"%s\" is already slave", driver_name);
 590         return true;
 591     }
 592
 593     driver_ptr = malloc(sizeof(struct jack_controller_slave_driver));
 594     if (driver_ptr == NULL)
 595     {
 596         jack_error("malloc() failed to allocate jack_controller_slave_driver struct");
 597         return false;
 598     }
 599
 600     driver_ptr->name = strdup(driver_name);
 601     if (driver_ptr->name == NULL)
 602     {
 603         jack_error("strdup() failed for slave driver name \"%s\"", driver_name);
 604         free(driver_ptr);
 605         return false;
 606     }
 607
 608     driver_ptr->handle = driver;
 609     driver_ptr->loaded = false;
 610
 611     jack_info("driver \"%s\" set as slave", driver_name);
 612
 613     list_add_tail(&driver_ptr->siblings, &controller_ptr->slave_drivers);
 614
 615     if (len_old != 0)
 616     {
 617         controller_ptr->slave_drivers_vparam_value.str[len_old++] = ',';
 618     }
 619
 620     memcpy(controller_ptr->slave_drivers_vparam_value.str + len_old, driver_name, len_new + 1);
 621     controller_ptr->slave_drivers_set = true;
 622
 623     return true;
 624 }
 625
 626 bool
 627 jack_controller_remove_slave_driver(
 628     struct jack_controller * controller_ptr,
 629     const char * driver_name)
 630 {
 631     struct list_head * node_ptr;
 632     struct jack_controller_slave_driver * driver_ptr;
 633
 634     list_for_each(node_ptr, &controller_ptr->slave_drivers)
 635     {
 636         driver_ptr = list_entry(node_ptr, struct jack_controller_slave_driver, siblings);
 637         if (strcmp(driver_ptr->name, driver_name) == 0)
 638         {
 639             list_del(&driver_ptr->siblings);
 640             free(driver_ptr->name);
 641             free(driver_ptr);
 642
 643             /* update the slave-drivers param value */
 644             controller_ptr->slave_drivers_vparam_value.str[0] = 0;
 645             list_for_each(node_ptr, &controller_ptr->slave_drivers)
 646             {
 647                 driver_ptr = list_entry(node_ptr, struct jack_controller_slave_driver, siblings);
 648                 if (controller_ptr->slave_drivers_vparam_value.str[0] != 0)
 649                 {
 650                     strcat(controller_ptr->slave_drivers_vparam_value.str, ",");
 651                 }
 652
 653                 strcat(controller_ptr->slave_drivers_vparam_value.str, driver_ptr->name);
 654             }
 655
 656             jack_info("driver \"%s\" is not slave anymore", driver_name);
 657
 658             return true;
 659         }
 660     }
 661
 662     return false;
 663 }
 664
 665 bool
 666 jack_controller_load_internal(
 667     struct jack_controller *controller_ptr,
 668     const char * internal_name)
 669 {
 670     jackctl_internal_t *internal;
 671
 672     internal = jack_controller_find_internal(controller_ptr->server, internal_name);
 673     if (internal == NULL)
 674     {
 675         return false;
 676     }
 677
 678     jack_info("internal \"%s\" selected", internal_name);
 679
 680     return jackctl_server_load_internal(controller_ptr->server, internal);
 681 }
 682
 683 bool
 684 jack_controller_unload_internal(
 685     struct jack_controller *controller_ptr,
 686     const char * internal_name)
 687 {
 688     jackctl_internal_t *internal;
 689
 690     internal = jack_controller_find_internal(controller_ptr->server, internal_name);
 691     if (internal == NULL)
 692     {
 693         return false;
 694     }
 695
 696     jack_info("internal \"%s\" selected", internal_name);
 697
 698     return jackctl_server_unload_internal(controller_ptr->server, internal);
 699 }
 700
 701 #define controller_ptr ((struct jack_controller *)context)
 702
 703 void
 704 jack_controller_destroy(
 705         void * context)
 706 {
 707     if (controller_ptr->started)
 708     {
 709         while (!jack_controller_stop_server(controller_ptr, NULL))
 710         {
 711             jack_info("jack server failed to stop, retrying in 3 seconds...");
 712             usleep(3000000);
 713         }
 714     }
 715
 716     jack_controller_remove_slave_drivers(controller_ptr);
 717     jack_params_destroy(controller_ptr->params);
 718     jackctl_server_destroy(controller_ptr->server);
 719     pthread_mutex_destroy(&controller_ptr->lock);
 720     free(controller_ptr);
 721 }
 722
 723 void
 724 jack_controller_run(
 725     void * context)
 726 {
 727     struct sysinfo si;
 728
 729     if (controller_ptr->pending_save == 0)
 730     {
 731         return;
 732     }
 733
 734     if (sysinfo(&si) != 0)
 735     {
 736         jack_error("sysinfo() failed with %d", errno);
 737     }
 738     else if (si.uptime < controller_ptr->pending_save + 2) /* delay save by two seconds */
 739     {
 740         return;
 741     }
 742
 743     controller_ptr->pending_save = 0;
 744     jack_controller_settings_save_auto(controller_ptr);
 745 }
 746
 747 #undef controller_ptr
 748
 749 void
 750 jack_controller_pending_save(
 751     struct jack_controller * controller_ptr)
 752 {
 753     struct sysinfo si;
 754
 755     if (sysinfo(&si) != 0)
 756     {
 757         jack_error("sysinfo() failed with %d.", errno);
 758         controller_ptr->pending_save = 0;
 759         jack_controller_settings_save_auto(controller_ptr);
 760         return;
 761     }
 762
 763     controller_ptr->pending_save = si.uptime;
 764 }