2 This file is part of PulseAudio.
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2006 Pierre Ossman <ossman@cendio.se> for Cendio AB
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
39 #include <sys/types.h>
42 #ifdef HAVE_SYS_MMAN_H
46 #ifdef HAVE_SYS_IOCTL_H
47 #include <sys/ioctl.h>
63 #include <dbus/dbus.h>
66 #include <pulse/client-conf.h>
68 #include <pulse/client-conf-x11.h>
70 #include <pulse/mainloop.h>
71 #include <pulse/mainloop-signal.h>
72 #include <pulse/timeval.h>
73 #include <pulse/xmalloc.h>
74 #include <pulse/i18n.h>
76 #include <pulsecore/lock-autospawn.h>
77 #include <pulsecore/winsock.h>
78 #include <pulsecore/core-error.h>
79 #include <pulsecore/core-rtclock.h>
80 #include <pulsecore/core.h>
81 #include <pulsecore/memblock.h>
82 #include <pulsecore/module.h>
83 #include <pulsecore/cli-command.h>
84 #include <pulsecore/log.h>
85 #include <pulsecore/core-util.h>
86 #include <pulsecore/sioman.h>
87 #include <pulsecore/cli-text.h>
88 #include <pulsecore/pid.h>
89 #include <pulsecore/namereg.h>
90 #include <pulsecore/random.h>
91 #include <pulsecore/macro.h>
92 #include <pulsecore/mutex.h>
93 #include <pulsecore/thread.h>
94 #include <pulsecore/once.h>
95 #include <pulsecore/shm.h>
96 #include <pulsecore/memtrap.h>
98 #include <pulsecore/dbus-shared.h>
100 #include <pulsecore/cpu-arm.h>
101 #include <pulsecore/cpu-x86.h>
104 #include "cpulimit.h"
105 #include "daemon-conf.h"
106 #include "dumpmodules.h"
108 #include "ltdl-bind-now.h"
109 #include "server-lookup.h"
112 /* Only one instance of these variables */
113 int allow_severity = LOG_INFO;
114 int deny_severity = LOG_WARNING;
117 #ifdef HAVE_OSS_WRAPPER
118 /* padsp looks for this symbol in the running process and disables
119 * itself if it finds it and it is set to 7 (which is actually a bit
120 * mask). For details see padsp. */
121 int __padsp_disabled__ = 7;
126 static void message_cb(pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata) {
128 struct timeval tvnext;
130 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
131 if (msg.message == WM_QUIT)
134 TranslateMessage(&msg);
135 DispatchMessage(&msg);
139 pa_timeval_add(pa_gettimeofday(&tvnext), 100000);
140 a->rtclock_time_restart(e, &tvnext);
145 static void signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
146 pa_log_info(_("Got signal %s."), pa_sig2str(sig));
151 pa_module_load(userdata, "module-cli", NULL);
157 pa_module_load(userdata, "module-cli-protocol-unix", NULL);
163 char *c = pa_full_status_string(userdata);
164 pa_log_notice("%s", c);
173 pa_log_info(_("Exiting."));
179 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
181 static int change_user(void) {
186 /* This function is called only in system-wide mode. It creates a
187 * runtime dir in /var/run/ with proper UID/GID and drops privs
190 if (!(pw = getpwnam(PA_SYSTEM_USER))) {
191 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
195 if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
196 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
200 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
201 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
202 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
204 if (pw->pw_gid != gr->gr_gid) {
205 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
209 if (strcmp(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH) != 0)
210 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
212 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid) < 0) {
213 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
217 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid) < 0) {
218 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
222 /* We don't create the config dir here, because we don't need to write to it */
224 if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
225 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
229 #if defined(HAVE_SETRESGID)
230 r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
231 #elif defined(HAVE_SETEGID)
232 if ((r = setgid(gr->gr_gid)) >= 0)
233 r = setegid(gr->gr_gid);
234 #elif defined(HAVE_SETREGID)
235 r = setregid(gr->gr_gid, gr->gr_gid);
237 #error "No API to drop privileges"
241 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
245 #if defined(HAVE_SETRESUID)
246 r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
247 #elif defined(HAVE_SETEUID)
248 if ((r = setuid(pw->pw_uid)) >= 0)
249 r = seteuid(pw->pw_uid);
250 #elif defined(HAVE_SETREUID)
251 r = setreuid(pw->pw_uid, pw->pw_uid);
253 #error "No API to drop privileges"
257 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
261 pa_set_env("USER", PA_SYSTEM_USER);
262 pa_set_env("USERNAME", PA_SYSTEM_USER);
263 pa_set_env("LOGNAME", PA_SYSTEM_USER);
264 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
266 /* Relevant for pa_runtime_path() */
267 if (!getenv("PULSE_RUNTIME_PATH"))
268 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
270 if (!getenv("PULSE_CONFIG_PATH"))
271 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
273 if (!getenv("PULSE_STATE_PATH"))
274 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
276 pa_log_info(_("Successfully dropped root privileges."));
281 #else /* HAVE_PWD_H && HAVE_GRP_H */
283 static int change_user(void) {
284 pa_log(_("System wide mode unsupported on this platform."));
288 #endif /* HAVE_PWD_H && HAVE_GRP_H */
290 #ifdef HAVE_SYS_RESOURCE_H
292 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
299 rl.rlim_cur = rl.rlim_max = r->value;
301 if (setrlimit(resource, &rl) < 0) {
302 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
309 static void set_all_rlimits(const pa_daemon_conf *conf) {
310 set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
311 set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
312 set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
313 set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
315 set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
318 set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
321 set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
323 #ifdef RLIMIT_MEMLOCK
324 set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
327 set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
330 set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
332 #ifdef RLIMIT_SIGPENDING
333 set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
335 #ifdef RLIMIT_MSGQUEUE
336 set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
339 set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
342 set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
345 set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
350 static char *check_configured_address(void) {
351 char *default_server = NULL;
352 pa_client_conf *c = pa_client_conf_new();
354 pa_client_conf_load(c, NULL);
356 pa_client_conf_from_x11(c, NULL);
358 pa_client_conf_env(c);
360 if (c->default_server && *c->default_server)
361 default_server = pa_xstrdup(c->default_server);
363 pa_client_conf_free(c);
365 return default_server;
369 static pa_dbus_connection *register_dbus_name(pa_core *c, DBusBusType bus, const char* name) {
371 pa_dbus_connection *conn;
373 dbus_error_init(&error);
375 if (!(conn = pa_dbus_bus_get(c, bus, &error)) || dbus_error_is_set(&error)) {
376 pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
380 if (dbus_bus_request_name(pa_dbus_connection_get(conn), name, DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
381 pa_log_debug("Got %s!", name);
385 if (dbus_error_is_set(&error))
386 pa_log_error("Failed to acquire %s: %s: %s", name, error.name, error.message);
388 pa_log_error("D-Bus name %s already taken. Weird shit!", name);
390 /* PA cannot be started twice by the same user and hence we can
391 * ignore mostly the case that a name is already taken. */
395 pa_dbus_connection_unref(conn);
397 dbus_error_free(&error);
402 int main(int argc, char *argv[]) {
404 pa_strbuf *buf = NULL;
405 pa_daemon_conf *conf = NULL;
406 pa_mainloop *mainloop = NULL;
408 char *configured_address;
409 int r = 0, retval = 1, d = 0;
410 pa_bool_t valid_pid_file = FALSE;
411 pa_bool_t ltdl_init = FALSE;
415 int daemon_pipe[2] = { -1, -1 };
418 pa_time_event *win32_timer;
419 struct timeval win32_tv;
421 int autospawn_fd = -1;
422 pa_bool_t autospawn_locked = FALSE;
424 pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
425 pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
426 pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
427 pa_bool_t start_server;
430 pa_log_set_ident("pulseaudio");
431 pa_log_set_level(PA_LOG_NOTICE);
432 pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
434 #if defined(__linux__) && defined(__OPTIMIZE__)
436 Disable lazy relocations to make usage of external libraries
437 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
438 a check whether we are a debug build or not. This all is
439 admittedly a bit snake-oilish.
442 if (!getenv("LD_BIND_NOW")) {
446 /* We have to execute ourselves, because the libc caches the
447 * value of $LD_BIND_NOW on initialization. */
449 pa_set_env("LD_BIND_NOW", "1");
451 if ((canonical_rp = pa_realpath(PA_BINARY))) {
453 if ((rp = pa_readlink("/proc/self/exe"))) {
455 if (pa_streq(rp, canonical_rp))
456 pa_assert_se(execv(rp, argv) == 0);
458 pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp);
463 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
465 pa_xfree(canonical_rp);
468 pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
472 if ((e = getenv("PULSE_PASSED_FD"))) {
479 /* We might be autospawned, in which case have no idea in which
480 * context we have been started. Let's cleanup our execution
481 * context as good as possible */
483 pa_reset_personality();
485 pa_close_all(passed_fd, -1);
490 setlocale(LC_ALL, "");
493 conf = pa_daemon_conf_new();
495 if (pa_daemon_conf_load(conf, NULL) < 0)
498 if (pa_daemon_conf_env(conf) < 0)
501 if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
502 pa_log(_("Failed to parse command line."));
506 pa_log_set_level(conf->log_level);
507 pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
509 pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
511 pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
512 pa_log_set_show_backtrace(conf->log_backtrace);
515 /* conf->system_instance and conf->local_server_type control almost the
516 * same thing; make them agree about what is requested. */
517 switch (conf->local_server_type) {
518 case PA_SERVER_TYPE_UNSET:
519 conf->local_server_type = conf->system_instance ? PA_SERVER_TYPE_SYSTEM : PA_SERVER_TYPE_USER;
521 case PA_SERVER_TYPE_USER:
522 case PA_SERVER_TYPE_NONE:
523 conf->system_instance = FALSE;
525 case PA_SERVER_TYPE_SYSTEM:
526 conf->system_instance = TRUE;
529 pa_assert_not_reached();
532 start_server = conf->local_server_type == PA_SERVER_TYPE_USER || (getuid() == 0 && conf->local_server_type == PA_SERVER_TYPE_SYSTEM);
534 if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
535 pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
536 conf->system_instance = FALSE;
540 LTDL_SET_PRELOADED_SYMBOLS();
544 if (conf->dl_search_path)
545 lt_dlsetsearchpath(conf->dl_search_path);
550 WSAStartup(MAKEWORD(2, 0), &data);
557 case PA_CMD_DUMP_MODULES:
558 pa_dump_modules(conf, argc-d, argv+d);
562 case PA_CMD_DUMP_CONF: {
565 pa_log("Too many arguments.\n");
569 s = pa_daemon_conf_dump(conf);
576 case PA_CMD_DUMP_RESAMPLE_METHODS: {
580 pa_log("Too many arguments.\n");
584 for (i = 0; i < PA_RESAMPLER_MAX; i++)
585 if (pa_resample_method_supported(i))
586 printf("%s\n", pa_resample_method_to_string(i));
593 pa_cmdline_help(argv[0]);
597 case PA_CMD_VERSION :
600 pa_log("Too many arguments.\n");
604 printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
612 pa_log("Too many arguments.\n");
616 if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
617 pa_log_info(_("Daemon not running"));
619 pa_log_info(_("Daemon running as PID %u"), pid);
629 pa_log("Too many arguments.\n");
633 if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
634 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
640 case PA_CMD_CLEANUP_SHM:
643 pa_log("Too many arguments.\n");
647 if (pa_shm_cleanup() >= 0)
653 pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
657 pa_log("Too many arguments.\n");
661 if (getuid() == 0 && !conf->system_instance)
662 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
663 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
664 else if (getuid() != 0 && conf->system_instance) {
665 pa_log(_("Root privileges required."));
670 if (conf->cmd == PA_CMD_START && conf->system_instance) {
671 pa_log(_("--start not supported for system instances."));
675 if (conf->cmd == PA_CMD_START && (configured_address = check_configured_address())) {
676 pa_log_notice(_("User-configured server at %s, not autospawning."), configured_address);
677 pa_xfree(configured_address);
682 if (conf->system_instance && !conf->disallow_exit)
683 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
685 if (conf->system_instance && !conf->disallow_module_loading)
686 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
688 if (conf->system_instance && !conf->disable_shm) {
689 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
690 conf->disable_shm = TRUE;
693 if (conf->system_instance && conf->exit_idle_time >= 0) {
694 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
695 conf->exit_idle_time = -1;
698 if (conf->cmd == PA_CMD_START) {
699 /* If we shall start PA only when it is not running yet, we
700 * first take the autospawn lock to make things
703 if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
704 pa_log("Failed to initialize autospawn lock");
708 if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
709 pa_log("Failed to acquire autospawn lock");
713 autospawn_locked = TRUE;
716 if (conf->daemonize) {
719 if (pa_stdio_acquire() < 0) {
720 pa_log(_("Failed to acquire stdio."));
725 if (pipe(daemon_pipe) < 0) {
726 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno));
730 if ((child = fork()) < 0) {
731 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
739 pa_assert_se(pa_close(daemon_pipe[1]) == 0);
742 if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
745 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
751 pa_log(_("Daemon startup failed."));
753 pa_log_info(_("Daemon startup successful."));
758 if (autospawn_fd >= 0) {
759 /* The lock file is unlocked from the parent, so we need
760 * to close it in the child */
762 pa_autospawn_lock_release();
763 pa_autospawn_lock_done(TRUE);
765 autospawn_locked = FALSE;
769 pa_assert_se(pa_close(daemon_pipe[0]) == 0);
773 if (conf->auto_log_target)
774 pa_log_set_target(PA_LOG_SYSLOG);
778 pa_log(_("setsid() failed: %s"), pa_cstrerror(errno));
783 /* We now are a session and process group leader. Let's fork
784 * again and let the father die, so that we'll become a
785 * process that can never acquire a TTY again, in a session and
786 * process group without leader */
789 if ((child = fork()) < 0) {
790 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
801 signal(SIGTTOU, SIG_IGN);
804 signal(SIGTTIN, SIG_IGN);
807 signal(SIGTSTP, SIG_IGN);
813 pa_set_env_and_record("PULSE_INTERNAL", "1");
814 pa_assert_se(chdir("/") == 0);
817 #ifdef HAVE_SYS_RESOURCE_H
818 set_all_rlimits(conf);
820 pa_rtclock_hrtimer_enable();
822 pa_raise_priority(conf->nice_level);
824 if (conf->system_instance)
825 if (change_user() < 0)
828 pa_set_env_and_record("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
830 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
831 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
832 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
834 s = pa_uname_string();
835 pa_log_debug(_("Running on host: %s"), s);
838 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
840 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
842 #ifdef HAVE_VALGRIND_MEMCHECK_H
843 pa_log_debug(_("Compiled with Valgrind support: yes"));
845 pa_log_debug(_("Compiled with Valgrind support: no"));
848 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
850 pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
853 pa_log_debug(_("Optimized build: yes"));
855 pa_log_debug(_("Optimized build: no"));
859 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
860 #elif defined(FASTPATH)
861 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
863 pa_log_debug(_("All asserts enabled."));
866 if (!(s = pa_machine_id())) {
867 pa_log(_("Failed to get machine ID"));
870 pa_log_info(_("Machine ID is %s."), s);
873 if ((s = pa_session_id())) {
874 pa_log_info(_("Session ID is %s."), s);
878 if (!(s = pa_get_runtime_dir()))
880 pa_log_info(_("Using runtime directory %s."), s);
883 if (!(s = pa_get_state_dir()))
885 pa_log_info(_("Using state directory %s."), s);
888 pa_log_info(_("Using modules directory %s."), conf->dl_search_path);
890 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
892 if (pa_in_system_mode())
893 pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
894 "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
895 "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
897 if (conf->use_pid_file) {
900 if ((z = pa_pid_file_create("pulseaudio")) != 0) {
902 if (conf->cmd == PA_CMD_START && z > 0) {
903 /* If we are already running and with are run in
904 * --start mode, then let's return this as success. */
910 pa_log(_("pa_pid_file_create() failed."));
914 valid_pid_file = TRUE;
917 pa_disable_sigpipe();
919 if (pa_rtclock_hrtimer())
920 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
922 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
924 if (conf->lock_memory) {
925 #ifdef HAVE_SYS_MMAN_H
926 if (mlockall(MCL_FUTURE) < 0)
927 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
929 pa_log_info("Sucessfully locked process into memory.");
931 pa_log_warn("Memory locking requested but not supported on platform.");
935 pa_memtrap_install();
937 pa_assert_se(mainloop = pa_mainloop_new());
939 if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
940 pa_log(_("pa_core_new() failed."));
944 c->default_sample_spec = conf->default_sample_spec;
945 c->default_channel_map = conf->default_channel_map;
946 c->default_n_fragments = conf->default_n_fragments;
947 c->default_fragment_size_msec = conf->default_fragment_size_msec;
948 c->sync_volume_safety_margin_usec = conf->sync_volume_safety_margin_usec;
949 c->sync_volume_extra_delay_usec = conf->sync_volume_extra_delay_usec;
950 c->exit_idle_time = conf->exit_idle_time;
951 c->scache_idle_time = conf->scache_idle_time;
952 c->resample_method = conf->resample_method;
953 c->realtime_priority = conf->realtime_priority;
954 c->realtime_scheduling = !!conf->realtime_scheduling;
955 c->disable_remixing = !!conf->disable_remixing;
956 c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
957 c->sync_volume = !!conf->sync_volume;
958 c->running_as_daemon = !!conf->daemonize;
959 c->disallow_exit = conf->disallow_exit;
960 c->flat_volumes = conf->flat_volumes;
962 c->server_type = conf->local_server_type;
965 c->cpu_info.cpu_type = PA_CPU_UNDEFINED;
966 if (!getenv("PULSE_NO_SIMD")) {
967 if (pa_cpu_init_x86(&(c->cpu_info.flags.x86)))
968 c->cpu_info.cpu_type = PA_CPU_X86;
969 if (pa_cpu_init_arm(&(c->cpu_info.flags.arm)))
970 c->cpu_info.cpu_type = PA_CPU_ARM;
973 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
974 pa_signal_new(SIGINT, signal_callback, c);
975 pa_signal_new(SIGTERM, signal_callback, c);
977 pa_signal_new(SIGUSR1, signal_callback, c);
980 pa_signal_new(SIGUSR2, signal_callback, c);
983 pa_signal_new(SIGHUP, signal_callback, c);
987 win32_timer = pa_mainloop_get_api(mainloop)->rtclock_time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
990 if (!conf->no_cpu_limit)
991 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
993 buf = pa_strbuf_new();
998 if (conf->load_default_script_file) {
1001 if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1002 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1008 r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1010 pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1013 if (r < 0 && conf->fail) {
1014 pa_log(_("Failed to initialize daemon."));
1018 if (!c->modules || pa_idxset_size(c->modules) == 0) {
1019 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1024 /* When we just provide the D-Bus server lookup service, we don't want
1025 * any modules to be loaded. We haven't loaded any so far, so one might
1026 * think there's no way to contact the server, but receiving certain
1027 * signals could still cause modules to load. */
1028 conf->disallow_module_loading = TRUE;
1032 /* We completed the initial module loading, so let's disable it
1033 * from now on, if requested */
1034 c->disallow_module_loading = !!conf->disallow_module_loading;
1037 if (!conf->system_instance) {
1038 if (!(server_lookup = pa_dbusobj_server_lookup_new(c)))
1040 if (!(lookup_service_bus = register_dbus_name(c, DBUS_BUS_SESSION, "org.PulseAudio1")))
1044 if (start_server && !(server_bus = register_dbus_name(c, conf->system_instance ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, "org.pulseaudio.Server")))
1049 if (daemon_pipe[1] >= 0) {
1051 pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1052 pa_close(daemon_pipe[1]);
1053 daemon_pipe[1] = -1;
1057 pa_log_info(_("Daemon startup complete."));
1060 if (pa_mainloop_run(mainloop, &retval) < 0)
1063 pa_log_info(_("Daemon shutdown initiated."));
1068 pa_dbus_connection_unref(server_bus);
1069 if (lookup_service_bus)
1070 pa_dbus_connection_unref(lookup_service_bus);
1072 pa_dbusobj_server_lookup_free(server_lookup);
1075 if (autospawn_fd >= 0) {
1076 if (autospawn_locked)
1077 pa_autospawn_lock_release();
1079 pa_autospawn_lock_done(FALSE);
1084 pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1089 pa_log_info(_("Daemon terminated."));
1092 if (!conf->no_cpu_limit)
1093 pa_cpu_limit_done();
1098 if (daemon_pipe[1] >= 0)
1099 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1101 pa_close_pipe(daemon_pipe);
1105 pa_mainloop_free(mainloop);
1108 pa_daemon_conf_free(conf);
1111 pa_pid_file_remove();
1113 /* This has no real purpose except making things valgrind-clean */
1114 pa_unset_env_recorded();