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>
41 #include <liboil/liboil.h>
43 #ifdef HAVE_SYS_IOCTL_H
44 #include <sys/ioctl.h>
60 #include <dbus/dbus.h>
63 #include <pulse/mainloop.h>
64 #include <pulse/mainloop-signal.h>
65 #include <pulse/timeval.h>
66 #include <pulse/xmalloc.h>
67 #include <pulse/i18n.h>
69 #include <pulsecore/lock-autospawn.h>
70 #include <pulsecore/winsock.h>
71 #include <pulsecore/core-error.h>
72 #include <pulsecore/core.h>
73 #include <pulsecore/memblock.h>
74 #include <pulsecore/module.h>
75 #include <pulsecore/cli-command.h>
76 #include <pulsecore/log.h>
77 #include <pulsecore/core-util.h>
78 #include <pulsecore/sioman.h>
79 #include <pulsecore/cli-text.h>
80 #include <pulsecore/pid.h>
81 #include <pulsecore/namereg.h>
82 #include <pulsecore/random.h>
83 #include <pulsecore/rtsig.h>
84 #include <pulsecore/rtclock.h>
85 #include <pulsecore/macro.h>
86 #include <pulsecore/mutex.h>
87 #include <pulsecore/thread.h>
88 #include <pulsecore/once.h>
89 #include <pulsecore/shm.h>
91 #include <pulsecore/dbus-shared.h>
96 #include "daemon-conf.h"
97 #include "dumpmodules.h"
99 #include "ltdl-bind-now.h"
103 /* Only one instance of these variables */
104 int allow_severity = LOG_INFO;
105 int deny_severity = LOG_WARNING;
109 /* padsp looks for this symbol in the running process and disables
110 * itself if it finds it and it is set to 7 (which is actually a bit
111 * mask). For details see padsp. */
112 int __padsp_disabled__ = 7;
117 static void message_cb(pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata) {
119 struct timeval tvnext;
121 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
122 if (msg.message == WM_QUIT)
125 TranslateMessage(&msg);
126 DispatchMessage(&msg);
130 pa_timeval_add(pa_gettimeofday(&tvnext), 100000);
131 a->time_restart(e, &tvnext);
136 static void signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
137 pa_log_info(_("Got signal %s."), pa_sig2str(sig));
142 pa_module_load(userdata, "module-cli", NULL);
148 pa_module_load(userdata, "module-cli-protocol-unix", NULL);
154 char *c = pa_full_status_string(userdata);
155 pa_log_notice("%s", c);
164 pa_log_info(_("Exiting."));
170 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
172 static int change_user(void) {
177 /* This function is called only in system-wide mode. It creates a
178 * runtime dir in /var/run/ with proper UID/GID and drops privs
181 if (!(pw = getpwnam(PA_SYSTEM_USER))) {
182 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
186 if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
187 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
191 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
192 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
193 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
195 if (pw->pw_gid != gr->gr_gid) {
196 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
200 if (strcmp(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH) != 0)
201 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
203 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid) < 0) {
204 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
208 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid) < 0) {
209 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
213 /* We don't create the config dir here, because we don't need to write to it */
215 if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
216 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
220 #if defined(HAVE_SETRESGID)
221 r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
222 #elif defined(HAVE_SETEGID)
223 if ((r = setgid(gr->gr_gid)) >= 0)
224 r = setegid(gr->gr_gid);
225 #elif defined(HAVE_SETREGID)
226 r = setregid(gr->gr_gid, gr->gr_gid);
228 #error "No API to drop privileges"
232 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
236 #if defined(HAVE_SETRESUID)
237 r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
238 #elif defined(HAVE_SETEUID)
239 if ((r = setuid(pw->pw_uid)) >= 0)
240 r = seteuid(pw->pw_uid);
241 #elif defined(HAVE_SETREUID)
242 r = setreuid(pw->pw_uid, pw->pw_uid);
244 #error "No API to drop privileges"
248 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
252 pa_set_env("USER", PA_SYSTEM_USER);
253 pa_set_env("USERNAME", PA_SYSTEM_USER);
254 pa_set_env("LOGNAME", PA_SYSTEM_USER);
255 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
257 /* Relevant for pa_runtime_path() */
258 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
259 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
260 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
262 pa_log_info(_("Successfully dropped root privileges."));
267 #else /* HAVE_PWD_H && HAVE_GRP_H */
269 static int change_user(void) {
270 pa_log(_("System wide mode unsupported on this platform."));
274 #endif /* HAVE_PWD_H && HAVE_GRP_H */
276 #ifdef HAVE_SYS_RESOURCE_H
278 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
285 rl.rlim_cur = rl.rlim_max = r->value;
287 if (setrlimit(resource, &rl) < 0) {
288 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
295 static void set_all_rlimits(const pa_daemon_conf *conf) {
296 set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
297 set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
298 set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
299 set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
301 set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
304 set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
307 set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
309 #ifdef RLIMIT_MEMLOCK
310 set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
313 set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
316 set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
318 #ifdef RLIMIT_SIGPENDING
319 set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
321 #ifdef RLIMIT_MSGQUEUE
322 set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
325 set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
328 set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
331 set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
337 static pa_dbus_connection *register_dbus(pa_core *c) {
339 pa_dbus_connection *conn;
341 dbus_error_init(&error);
343 if (!(conn = pa_dbus_bus_get(c, pa_in_system_mode() ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
344 pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
348 if (dbus_bus_request_name(pa_dbus_connection_get(conn), "org.pulseaudio.Server", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
349 pa_log_debug("Got org.pulseaudio.Server!");
353 if (dbus_error_is_set(&error))
354 pa_log_warn("Failed to acquire org.pulseaudio.Server: %s: %s", error.name, error.message);
356 pa_log_warn("D-Bus name org.pulseaudio.Server already taken. Weird shit!");
358 /* PA cannot be started twice by the same user and hence we can
359 * ignore mostly the case that org.pulseaudio.Server is already
365 pa_dbus_connection_unref(conn);
367 dbus_error_free(&error);
372 int main(int argc, char *argv[]) {
374 pa_strbuf *buf = NULL;
375 pa_daemon_conf *conf = NULL;
376 pa_mainloop *mainloop = NULL;
378 int r = 0, retval = 1, d = 0;
379 pa_bool_t suid_root, real_root;
380 pa_bool_t valid_pid_file = FALSE;
381 gid_t gid = (gid_t) -1;
382 pa_bool_t ltdl_init = FALSE;
386 int daemon_pipe[2] = { -1, -1 };
389 pa_time_event *win32_timer;
390 struct timeval win32_tv;
392 int autospawn_fd = -1;
393 pa_bool_t autospawn_locked = FALSE;
395 pa_dbus_connection *dbus = NULL;
398 pa_log_set_ident("pulseaudio");
399 pa_log_set_level(PA_LOG_NOTICE);
400 pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
402 #if defined(__linux__) && defined(__OPTIMIZE__)
404 Disable lazy relocations to make usage of external libraries
405 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
406 a check whether we are a debug build or not.
409 if (!getenv("LD_BIND_NOW")) {
412 /* We have to execute ourselves, because the libc caches the
413 * value of $LD_BIND_NOW on initialization. */
415 pa_set_env("LD_BIND_NOW", "1");
417 if ((rp = pa_readlink("/proc/self/exe")))
418 pa_assert_se(execv(rp, argv) == 0);
420 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
425 real_root = getuid() == 0;
426 suid_root = !real_root && geteuid() == 0;
433 /* Drop all capabilities except CAP_SYS_NICE */
436 /* Drop privileges, but keep CAP_SYS_NICE */
439 /* After dropping root, the effective set is reset, hence,
440 * let's raise it again */
443 /* When capabilities are not supported we will not be able to
444 * acquire RT sched anymore. But yes, that's the way it is. It
445 * is just too risky tun let PA run as root all the time. */
448 if ((e = getenv("PULSE_PASSED_FD"))) {
455 pa_close_all(passed_fd, -1);
460 /* At this point, we are a normal user, possibly with CAP_NICE if
461 * we were started SUID. If we are started as normal root, than we
462 * still are normal root. */
464 setlocale(LC_ALL, "");
467 conf = pa_daemon_conf_new();
469 if (pa_daemon_conf_load(conf, NULL) < 0)
472 if (pa_daemon_conf_env(conf) < 0)
475 if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
476 pa_log(_("Failed to parse command line."));
480 pa_log_set_level(conf->log_level);
481 pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
483 pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
485 pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
486 pa_log_set_show_backtrace(conf->log_backtrace);
488 pa_log_debug("Started as real root: %s, suid root: %s", pa_yes_no(real_root), pa_yes_no(suid_root));
490 if (!real_root && pa_have_caps()) {
491 #ifdef HAVE_SYS_RESOURCE_H
494 pa_bool_t allow_high_priority = FALSE, allow_realtime = FALSE;
496 /* Let's better not enable high prio or RT by default */
498 if (conf->high_priority && !allow_high_priority) {
499 if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
500 pa_log_info(_("We're in the group '%s', allowing high-priority scheduling."), PA_REALTIME_GROUP);
501 allow_high_priority = TRUE;
505 if (conf->realtime_scheduling && !allow_realtime) {
506 if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
507 pa_log_info(_("We're in the group '%s', allowing real-time scheduling."), PA_REALTIME_GROUP);
508 allow_realtime = TRUE;
513 if (conf->high_priority && !allow_high_priority) {
514 if (pa_polkit_check("org.pulseaudio.acquire-high-priority") > 0) {
515 pa_log_info(_("PolicyKit grants us acquire-high-priority privilege."));
516 allow_high_priority = TRUE;
518 pa_log_info(_("PolicyKit refuses acquire-high-priority privilege."));
521 if (conf->realtime_scheduling && !allow_realtime) {
522 if (pa_polkit_check("org.pulseaudio.acquire-real-time") > 0) {
523 pa_log_info(_("PolicyKit grants us acquire-real-time privilege."));
524 allow_realtime = TRUE;
526 pa_log_info(_("PolicyKit refuses acquire-real-time privilege."));
530 if (!allow_high_priority && !allow_realtime) {
532 /* OK, there's no further need to keep CAP_NICE. Hence
533 * let's give it up early */
539 if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0)
540 if (rl.rlim_cur > 0) {
541 pa_log_info("RLIMIT_RTPRIO is set to %u, allowing real-time scheduling.", (unsigned) rl.rlim_cur);
542 allow_realtime = TRUE;
546 if (getrlimit(RLIMIT_NICE, &rl) >= 0)
547 if (rl.rlim_cur > 20 ) {
548 pa_log_info("RLIMIT_NICE is set to %u, allowing high-priority scheduling.", (unsigned) rl.rlim_cur);
549 allow_high_priority = TRUE;
553 if ((conf->high_priority && !allow_high_priority) ||
554 (conf->realtime_scheduling && !allow_realtime))
555 pa_log_info(_("Called SUID root and real-time and/or high-priority scheduling was requested in the configuration. However, we lack the necessary privileges:\n"
556 "We are not in group '%s', PolicyKit refuse to grant us the requested privileges and we have no increase RLIMIT_NICE/RLIMIT_RTPRIO resource limits.\n"
557 "For enabling real-time/high-priority scheduling please acquire the appropriate PolicyKit privileges, or become a member of '%s', or increase the RLIMIT_NICE/RLIMIT_RTPRIO resource limits for this user."),
558 PA_REALTIME_GROUP, PA_REALTIME_GROUP);
562 conf->realtime_scheduling = FALSE;
564 if (!allow_high_priority)
565 conf->high_priority = FALSE;
568 #ifdef HAVE_SYS_RESOURCE_H
569 /* Reset resource limits. If we are run as root (for system mode)
570 * this might end up increasing the limits, which is intended
571 * behaviour. For all other cases, i.e. started as normal user, or
572 * SUID root at this point we should have no CAP_SYS_RESOURCE and
573 * increasing the limits thus should fail. Which is, too, intended
576 set_all_rlimits(conf);
579 if (conf->high_priority && !pa_can_high_priority()) {
580 pa_log_info(_("High-priority scheduling enabled in configuration but not allowed by policy."));
581 conf->high_priority = FALSE;
584 if (conf->high_priority && (conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START))
585 pa_raise_priority(conf->nice_level);
587 pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
589 if (!real_root && pa_have_caps()) {
592 drop = (conf->cmd != PA_CMD_DAEMON && conf->cmd != PA_CMD_START) || !conf->realtime_scheduling;
597 /* At this point we still have CAP_NICE if we were loaded
598 * SUID root. If possible let's acquire RLIMIT_RTPRIO
599 * instead and give CAP_NICE up. */
601 if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
603 if (rl.rlim_cur >= 9)
606 rl.rlim_max = rl.rlim_cur = 9;
608 if (setrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
609 pa_log_info(_("Successfully increased RLIMIT_RTPRIO"));
612 pa_log_warn(_("RLIMIT_RTPRIO failed: %s"), pa_cstrerror(errno));
619 pa_log_info(_("Giving up CAP_NICE"));
625 if (conf->realtime_scheduling && !pa_can_realtime()) {
626 pa_log_info(_("Real-time scheduling enabled in configuration but not allowed by policy."));
627 conf->realtime_scheduling = FALSE;
630 pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
632 LTDL_SET_PRELOADED_SYMBOLS();
636 if (conf->dl_search_path)
637 lt_dlsetsearchpath(conf->dl_search_path);
642 WSAStartup(MAKEWORD(2, 0), &data);
649 case PA_CMD_DUMP_MODULES:
650 pa_dump_modules(conf, argc-d, argv+d);
654 case PA_CMD_DUMP_CONF: {
655 s = pa_daemon_conf_dump(conf);
662 case PA_CMD_DUMP_RESAMPLE_METHODS: {
665 for (i = 0; i < PA_RESAMPLER_MAX; i++)
666 if (pa_resample_method_supported(i))
667 printf("%s\n", pa_resample_method_to_string(i));
674 pa_cmdline_help(argv[0]);
678 case PA_CMD_VERSION :
679 printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
686 if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
687 pa_log_info(_("Daemon not running"));
689 pa_log_info(_("Daemon running as PID %u"), pid);
698 if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
699 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
705 case PA_CMD_CLEANUP_SHM:
707 if (pa_shm_cleanup() >= 0)
713 pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
716 if (real_root && !conf->system_instance)
717 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
718 else if (!real_root && conf->system_instance) {
719 pa_log(_("Root privileges required."));
723 if (conf->cmd == PA_CMD_START && conf->system_instance) {
724 pa_log(_("--start not supported for system instances."));
728 if (conf->system_instance && !conf->disallow_exit)
729 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
731 if (conf->system_instance && !conf->disallow_module_loading)
732 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
734 if (conf->system_instance && !conf->disable_shm) {
735 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
736 conf->disable_shm = TRUE;
739 if (conf->system_instance && conf->exit_idle_time >= 0) {
740 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
741 conf->exit_idle_time = -1;
744 if (conf->cmd == PA_CMD_START) {
745 /* If we shall start PA only when it is not running yet, we
746 * first take the autospawn lock to make things
749 if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
750 pa_log("Failed to initialize autospawn lock");
754 if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
755 pa_log("Failed to acquire autospawn lock");
759 autospawn_locked = TRUE;
762 if (conf->daemonize) {
766 if (pa_stdio_acquire() < 0) {
767 pa_log(_("Failed to acquire stdio."));
772 if (pipe(daemon_pipe) < 0) {
773 pa_log(_("pipe failed: %s"), pa_cstrerror(errno));
777 if ((child = fork()) < 0) {
778 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
786 pa_assert_se(pa_close(daemon_pipe[1]) == 0);
789 if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
792 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
798 pa_log(_("Daemon startup failed."));
800 pa_log_info(_("Daemon startup successful."));
805 if (autospawn_fd >= 0) {
806 /* The lock file is unlocked from the parent, so we need
807 * to close it in the child */
809 pa_autospawn_lock_release();
810 pa_autospawn_lock_done(TRUE);
812 autospawn_locked = FALSE;
816 pa_assert_se(pa_close(daemon_pipe[0]) == 0);
820 if (conf->auto_log_target)
821 pa_log_set_target(PA_LOG_SYSLOG);
835 pa_assert_se(open("/dev/null", O_RDONLY) == 0);
836 pa_assert_se(open("/dev/null", O_WRONLY) == 1);
837 pa_assert_se(open("/dev/null", O_WRONLY) == 2);
843 signal(SIGTTOU, SIG_IGN);
846 signal(SIGTTIN, SIG_IGN);
849 signal(SIGTSTP, SIG_IGN);
853 if ((tty_fd = open("/dev/tty", O_RDWR)) >= 0) {
854 ioctl(tty_fd, TIOCNOTTY, (char*) 0);
855 pa_assert_se(pa_close(tty_fd) == 0);
860 pa_set_env("PULSE_INTERNAL", "1");
861 pa_assert_se(chdir("/") == 0);
864 if (conf->system_instance)
865 if (change_user() < 0)
868 pa_set_env("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
870 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
871 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
872 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
874 s = pa_uname_string();
875 pa_log_debug(_("Running on host: %s"), s);
878 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
880 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
882 #ifdef HAVE_VALGRIND_MEMCHECK_H
883 pa_log_debug(_("Compiled with Valgrind support: yes"));
885 pa_log_debug(_("Compiled with Valgrind support: no"));
888 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
891 pa_log_debug(_("Optimized build: yes"));
893 pa_log_debug(_("Optimized build: no"));
897 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
898 #elif defined(FASTPATH)
899 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
901 pa_log_debug(_("All asserts enabled."));
904 if (!(s = pa_machine_id())) {
905 pa_log(_("Failed to get machine ID"));
908 pa_log_info(_("Machine ID is %s."), s);
911 if ((s = pa_session_id())) {
912 pa_log_info(_("Session ID is %s."), s);
916 if (!(s = pa_get_runtime_dir()))
918 pa_log_info(_("Using runtime directory %s."), s);
921 if (!(s = pa_get_state_dir()))
923 pa_log_info(_("Using state directory %s."), s);
926 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
928 if (conf->use_pid_file) {
931 if ((z = pa_pid_file_create("pulseaudio")) != 0) {
933 if (conf->cmd == PA_CMD_START && z > 0) {
934 /* If we are already running and with are run in
935 * --start mode, then let's return this as success. */
941 pa_log(_("pa_pid_file_create() failed."));
945 valid_pid_file = TRUE;
949 signal(SIGPIPE, SIG_IGN);
952 if (pa_rtclock_hrtimer())
953 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
955 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
957 pa_rtclock_hrtimer_enable();
960 /* Valgrind uses SIGRTMAX. To easy debugging we don't use it here */
961 pa_rtsig_configure(SIGRTMIN, SIGRTMAX-1);
964 pa_assert_se(mainloop = pa_mainloop_new());
966 if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
967 pa_log(_("pa_core_new() failed."));
971 c->default_sample_spec = conf->default_sample_spec;
972 c->default_channel_map = conf->default_channel_map;
973 c->default_n_fragments = conf->default_n_fragments;
974 c->default_fragment_size_msec = conf->default_fragment_size_msec;
975 c->exit_idle_time = conf->exit_idle_time;
976 c->scache_idle_time = conf->scache_idle_time;
977 c->resample_method = conf->resample_method;
978 c->realtime_priority = conf->realtime_priority;
979 c->realtime_scheduling = !!conf->realtime_scheduling;
980 c->disable_remixing = !!conf->disable_remixing;
981 c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
982 c->running_as_daemon = !!conf->daemonize;
983 c->disallow_exit = conf->disallow_exit;
984 c->flat_volumes = conf->flat_volumes;
986 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
987 pa_signal_new(SIGINT, signal_callback, c);
988 pa_signal_new(SIGTERM, signal_callback, c);
990 pa_signal_new(SIGUSR1, signal_callback, c);
993 pa_signal_new(SIGUSR2, signal_callback, c);
996 pa_signal_new(SIGHUP, signal_callback, c);
1000 win32_timer = pa_mainloop_get_api(mainloop)->time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
1005 if (!conf->no_cpu_limit)
1006 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1008 buf = pa_strbuf_new();
1009 if (conf->load_default_script_file) {
1012 if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1013 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1019 r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1021 pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1024 /* We completed the initial module loading, so let's disable it
1025 * from now on, if requested */
1026 c->disallow_module_loading = !!conf->disallow_module_loading;
1028 if (r < 0 && conf->fail) {
1029 pa_log(_("Failed to initialize daemon."));
1033 if (!c->modules || pa_idxset_size(c->modules) == 0) {
1034 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1039 if (daemon_pipe[1] >= 0) {
1041 pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1042 pa_close(daemon_pipe[1]);
1043 daemon_pipe[1] = -1;
1048 dbus = register_dbus(c);
1051 pa_log_info(_("Daemon startup complete."));
1054 if (pa_mainloop_run(mainloop, &retval) < 0)
1057 pa_log_info(_("Daemon shutdown initiated."));
1062 pa_dbus_connection_unref(dbus);
1065 if (autospawn_fd >= 0) {
1066 if (autospawn_locked)
1067 pa_autospawn_lock_release();
1069 pa_autospawn_lock_done(FALSE);
1074 pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1079 pa_log_info(_("Daemon terminated."));
1082 if (!conf->no_cpu_limit)
1083 pa_cpu_limit_done();
1088 if (daemon_pipe[1] >= 0)
1089 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1091 pa_close_pipe(daemon_pipe);
1095 pa_mainloop_free(mainloop);
1098 pa_daemon_conf_free(conf);
1101 pa_pid_file_remove();