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_MMAN_H
47 #ifdef HAVE_SYS_IOCTL_H
48 #include <sys/ioctl.h>
64 #include <dbus/dbus.h>
67 #include <pulse/mainloop.h>
68 #include <pulse/mainloop-signal.h>
69 #include <pulse/timeval.h>
70 #include <pulse/xmalloc.h>
71 #include <pulse/i18n.h>
73 #include <pulsecore/lock-autospawn.h>
74 #include <pulsecore/winsock.h>
75 #include <pulsecore/core-error.h>
76 #include <pulsecore/core.h>
77 #include <pulsecore/memblock.h>
78 #include <pulsecore/module.h>
79 #include <pulsecore/cli-command.h>
80 #include <pulsecore/log.h>
81 #include <pulsecore/core-util.h>
82 #include <pulsecore/sioman.h>
83 #include <pulsecore/cli-text.h>
84 #include <pulsecore/pid.h>
85 #include <pulsecore/namereg.h>
86 #include <pulsecore/random.h>
87 #include <pulsecore/rtsig.h>
88 #include <pulsecore/rtclock.h>
89 #include <pulsecore/macro.h>
90 #include <pulsecore/mutex.h>
91 #include <pulsecore/thread.h>
92 #include <pulsecore/once.h>
93 #include <pulsecore/shm.h>
94 #include <pulsecore/memtrap.h>
96 #include <pulsecore/dbus-shared.h>
100 #include "cpulimit.h"
101 #include "daemon-conf.h"
102 #include "dumpmodules.h"
104 #include "ltdl-bind-now.h"
108 /* Only one instance of these variables */
109 int allow_severity = LOG_INFO;
110 int deny_severity = LOG_WARNING;
114 /* padsp looks for this symbol in the running process and disables
115 * itself if it finds it and it is set to 7 (which is actually a bit
116 * mask). For details see padsp. */
117 int __padsp_disabled__ = 7;
122 static void message_cb(pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata) {
124 struct timeval tvnext;
126 while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
127 if (msg.message == WM_QUIT)
130 TranslateMessage(&msg);
131 DispatchMessage(&msg);
135 pa_timeval_add(pa_gettimeofday(&tvnext), 100000);
136 a->time_restart(e, &tvnext);
141 static void signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
142 pa_log_info(_("Got signal %s."), pa_sig2str(sig));
147 pa_module_load(userdata, "module-cli", NULL);
153 pa_module_load(userdata, "module-cli-protocol-unix", NULL);
159 char *c = pa_full_status_string(userdata);
160 pa_log_notice("%s", c);
169 pa_log_info(_("Exiting."));
175 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
177 static int change_user(void) {
182 /* This function is called only in system-wide mode. It creates a
183 * runtime dir in /var/run/ with proper UID/GID and drops privs
186 if (!(pw = getpwnam(PA_SYSTEM_USER))) {
187 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER);
191 if (!(gr = getgrnam(PA_SYSTEM_GROUP))) {
192 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP);
196 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
197 PA_SYSTEM_USER, (unsigned long) pw->pw_uid,
198 PA_SYSTEM_GROUP, (unsigned long) gr->gr_gid);
200 if (pw->pw_gid != gr->gr_gid) {
201 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER, PA_SYSTEM_GROUP);
205 if (strcmp(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH) != 0)
206 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
208 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid) < 0) {
209 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
213 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid) < 0) {
214 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
218 /* We don't create the config dir here, because we don't need to write to it */
220 if (initgroups(PA_SYSTEM_USER, gr->gr_gid) != 0) {
221 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno));
225 #if defined(HAVE_SETRESGID)
226 r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
227 #elif defined(HAVE_SETEGID)
228 if ((r = setgid(gr->gr_gid)) >= 0)
229 r = setegid(gr->gr_gid);
230 #elif defined(HAVE_SETREGID)
231 r = setregid(gr->gr_gid, gr->gr_gid);
233 #error "No API to drop privileges"
237 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno));
241 #if defined(HAVE_SETRESUID)
242 r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
243 #elif defined(HAVE_SETEUID)
244 if ((r = setuid(pw->pw_uid)) >= 0)
245 r = seteuid(pw->pw_uid);
246 #elif defined(HAVE_SETREUID)
247 r = setreuid(pw->pw_uid, pw->pw_uid);
249 #error "No API to drop privileges"
253 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno));
257 pa_set_env("USER", PA_SYSTEM_USER);
258 pa_set_env("USERNAME", PA_SYSTEM_USER);
259 pa_set_env("LOGNAME", PA_SYSTEM_USER);
260 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH);
262 /* Relevant for pa_runtime_path() */
263 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH);
264 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH);
265 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH);
267 pa_log_info(_("Successfully dropped root privileges."));
272 #else /* HAVE_PWD_H && HAVE_GRP_H */
274 static int change_user(void) {
275 pa_log(_("System wide mode unsupported on this platform."));
279 #endif /* HAVE_PWD_H && HAVE_GRP_H */
281 #ifdef HAVE_SYS_RESOURCE_H
283 static int set_one_rlimit(const pa_rlimit *r, int resource, const char *name) {
290 rl.rlim_cur = rl.rlim_max = r->value;
292 if (setrlimit(resource, &rl) < 0) {
293 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name, (unsigned) r->value, (unsigned) r->value, pa_cstrerror(errno));
300 static void set_all_rlimits(const pa_daemon_conf *conf) {
301 set_one_rlimit(&conf->rlimit_fsize, RLIMIT_FSIZE, "RLIMIT_FSIZE");
302 set_one_rlimit(&conf->rlimit_data, RLIMIT_DATA, "RLIMIT_DATA");
303 set_one_rlimit(&conf->rlimit_stack, RLIMIT_STACK, "RLIMIT_STACK");
304 set_one_rlimit(&conf->rlimit_core, RLIMIT_CORE, "RLIMIT_CORE");
306 set_one_rlimit(&conf->rlimit_rss, RLIMIT_RSS, "RLIMIT_RSS");
309 set_one_rlimit(&conf->rlimit_nproc, RLIMIT_NPROC, "RLIMIT_NPROC");
312 set_one_rlimit(&conf->rlimit_nofile, RLIMIT_NOFILE, "RLIMIT_NOFILE");
314 #ifdef RLIMIT_MEMLOCK
315 set_one_rlimit(&conf->rlimit_memlock, RLIMIT_MEMLOCK, "RLIMIT_MEMLOCK");
318 set_one_rlimit(&conf->rlimit_as, RLIMIT_AS, "RLIMIT_AS");
321 set_one_rlimit(&conf->rlimit_locks, RLIMIT_LOCKS, "RLIMIT_LOCKS");
323 #ifdef RLIMIT_SIGPENDING
324 set_one_rlimit(&conf->rlimit_sigpending, RLIMIT_SIGPENDING, "RLIMIT_SIGPENDING");
326 #ifdef RLIMIT_MSGQUEUE
327 set_one_rlimit(&conf->rlimit_msgqueue, RLIMIT_MSGQUEUE, "RLIMIT_MSGQUEUE");
330 set_one_rlimit(&conf->rlimit_nice, RLIMIT_NICE, "RLIMIT_NICE");
333 set_one_rlimit(&conf->rlimit_rtprio, RLIMIT_RTPRIO, "RLIMIT_RTPRIO");
336 set_one_rlimit(&conf->rlimit_rttime, RLIMIT_RTTIME, "RLIMIT_RTTIME");
342 static pa_dbus_connection *register_dbus(pa_core *c) {
344 pa_dbus_connection *conn;
346 dbus_error_init(&error);
348 if (!(conn = pa_dbus_bus_get(c, pa_in_system_mode() ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
349 pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
353 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) {
354 pa_log_debug("Got org.pulseaudio.Server!");
358 if (dbus_error_is_set(&error))
359 pa_log_warn("Failed to acquire org.pulseaudio.Server: %s: %s", error.name, error.message);
361 pa_log_warn("D-Bus name org.pulseaudio.Server already taken. Weird shit!");
363 /* PA cannot be started twice by the same user and hence we can
364 * ignore mostly the case that org.pulseaudio.Server is already
370 pa_dbus_connection_unref(conn);
372 dbus_error_free(&error);
377 int main(int argc, char *argv[]) {
379 pa_strbuf *buf = NULL;
380 pa_daemon_conf *conf = NULL;
381 pa_mainloop *mainloop = NULL;
383 int r = 0, retval = 1, d = 0;
384 pa_bool_t suid_root, real_root;
385 pa_bool_t valid_pid_file = FALSE;
386 gid_t gid = (gid_t) -1;
387 pa_bool_t ltdl_init = FALSE;
391 int daemon_pipe[2] = { -1, -1 };
394 pa_time_event *win32_timer;
395 struct timeval win32_tv;
397 int autospawn_fd = -1;
398 pa_bool_t autospawn_locked = FALSE;
400 pa_dbus_connection *dbus = NULL;
403 pa_log_set_ident("pulseaudio");
404 pa_log_set_level(PA_LOG_NOTICE);
405 pa_log_set_flags(PA_LOG_COLORS|PA_LOG_PRINT_FILE|PA_LOG_PRINT_LEVEL, PA_LOG_RESET);
407 #if defined(__linux__) && defined(__OPTIMIZE__)
409 Disable lazy relocations to make usage of external libraries
410 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
411 a check whether we are a debug build or not.
414 if (!getenv("LD_BIND_NOW")) {
417 /* We have to execute ourselves, because the libc caches the
418 * value of $LD_BIND_NOW on initialization. */
420 pa_set_env("LD_BIND_NOW", "1");
422 if ((rp = pa_readlink("/proc/self/exe")))
423 pa_assert_se(execv(rp, argv) == 0);
425 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
430 real_root = getuid() == 0;
431 suid_root = !real_root && geteuid() == 0;
438 /* Drop all capabilities except CAP_SYS_NICE */
441 /* Drop privileges, but keep CAP_SYS_NICE */
444 /* After dropping root, the effective set is reset, hence,
445 * let's raise it again */
448 /* When capabilities are not supported we will not be able to
449 * acquire RT sched anymore. But yes, that's the way it is. It
450 * is just too risky tun let PA run as root all the time. */
453 if ((e = getenv("PULSE_PASSED_FD"))) {
460 pa_close_all(passed_fd, -1);
465 /* At this point, we are a normal user, possibly with CAP_NICE if
466 * we were started SUID. If we are started as normal root, than we
467 * still are normal root. */
469 setlocale(LC_ALL, "");
472 conf = pa_daemon_conf_new();
474 if (pa_daemon_conf_load(conf, NULL) < 0)
477 if (pa_daemon_conf_env(conf) < 0)
480 if (pa_cmdline_parse(conf, argc, argv, &d) < 0) {
481 pa_log(_("Failed to parse command line."));
485 pa_log_set_level(conf->log_level);
486 pa_log_set_target(conf->auto_log_target ? PA_LOG_STDERR : conf->log_target);
488 pa_log_set_flags(PA_LOG_PRINT_META, PA_LOG_SET);
490 pa_log_set_flags(PA_LOG_PRINT_TIME, PA_LOG_SET);
491 pa_log_set_show_backtrace(conf->log_backtrace);
493 pa_log_debug("Started as real root: %s, suid root: %s", pa_yes_no(real_root), pa_yes_no(suid_root));
495 if (!real_root && pa_have_caps()) {
496 #ifdef HAVE_SYS_RESOURCE_H
499 pa_bool_t allow_high_priority = FALSE, allow_realtime = FALSE;
501 /* Let's better not enable high prio or RT by default */
503 if (conf->high_priority && !allow_high_priority) {
504 if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
505 pa_log_info(_("We're in the group '%s', allowing high-priority scheduling."), PA_REALTIME_GROUP);
506 allow_high_priority = TRUE;
510 if (conf->realtime_scheduling && !allow_realtime) {
511 if (pa_own_uid_in_group(PA_REALTIME_GROUP, &gid) > 0) {
512 pa_log_info(_("We're in the group '%s', allowing real-time scheduling."), PA_REALTIME_GROUP);
513 allow_realtime = TRUE;
518 if (conf->high_priority && !allow_high_priority) {
519 if (pa_polkit_check("org.pulseaudio.acquire-high-priority") > 0) {
520 pa_log_info(_("PolicyKit grants us acquire-high-priority privilege."));
521 allow_high_priority = TRUE;
523 pa_log_info(_("PolicyKit refuses acquire-high-priority privilege."));
526 if (conf->realtime_scheduling && !allow_realtime) {
527 if (pa_polkit_check("org.pulseaudio.acquire-real-time") > 0) {
528 pa_log_info(_("PolicyKit grants us acquire-real-time privilege."));
529 allow_realtime = TRUE;
531 pa_log_info(_("PolicyKit refuses acquire-real-time privilege."));
535 if (!allow_high_priority && !allow_realtime) {
537 /* OK, there's no further need to keep CAP_NICE. Hence
538 * let's give it up early */
544 if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0)
545 if (rl.rlim_cur > 0) {
546 pa_log_info("RLIMIT_RTPRIO is set to %u, allowing real-time scheduling.", (unsigned) rl.rlim_cur);
547 allow_realtime = TRUE;
551 if (getrlimit(RLIMIT_NICE, &rl) >= 0)
552 if (rl.rlim_cur > 20 ) {
553 pa_log_info("RLIMIT_NICE is set to %u, allowing high-priority scheduling.", (unsigned) rl.rlim_cur);
554 allow_high_priority = TRUE;
558 if ((conf->high_priority && !allow_high_priority) ||
559 (conf->realtime_scheduling && !allow_realtime))
560 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"
561 "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"
562 "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."),
563 PA_REALTIME_GROUP, PA_REALTIME_GROUP);
567 conf->realtime_scheduling = FALSE;
569 if (!allow_high_priority)
570 conf->high_priority = FALSE;
573 #ifdef HAVE_SYS_RESOURCE_H
574 /* Reset resource limits. If we are run as root (for system mode)
575 * this might end up increasing the limits, which is intended
576 * behaviour. For all other cases, i.e. started as normal user, or
577 * SUID root at this point we should have no CAP_SYS_RESOURCE and
578 * increasing the limits thus should fail. Which is, too, intended
581 set_all_rlimits(conf);
584 if (conf->high_priority && !pa_can_high_priority()) {
585 pa_log_info(_("High-priority scheduling enabled in configuration but not allowed by policy."));
586 conf->high_priority = FALSE;
589 if (conf->high_priority && (conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START))
590 pa_raise_priority(conf->nice_level);
592 pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
594 if (!real_root && pa_have_caps()) {
597 drop = (conf->cmd != PA_CMD_DAEMON && conf->cmd != PA_CMD_START) || !conf->realtime_scheduling;
602 /* At this point we still have CAP_NICE if we were loaded
603 * SUID root. If possible let's acquire RLIMIT_RTPRIO
604 * instead and give CAP_NICE up. */
606 if (getrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
608 if (rl.rlim_cur >= 9)
611 rl.rlim_max = rl.rlim_cur = 9;
613 if (setrlimit(RLIMIT_RTPRIO, &rl) >= 0) {
614 pa_log_info(_("Successfully increased RLIMIT_RTPRIO"));
617 pa_log_warn(_("RLIMIT_RTPRIO failed: %s"), pa_cstrerror(errno));
624 pa_log_info(_("Giving up CAP_NICE"));
630 if (conf->realtime_scheduling && !pa_can_realtime()) {
631 pa_log_info(_("Real-time scheduling enabled in configuration but not allowed by policy."));
632 conf->realtime_scheduling = FALSE;
635 pa_log_debug("Can realtime: %s, can high-priority: %s", pa_yes_no(pa_can_realtime()), pa_yes_no(pa_can_high_priority()));
637 LTDL_SET_PRELOADED_SYMBOLS();
641 if (conf->dl_search_path)
642 lt_dlsetsearchpath(conf->dl_search_path);
647 WSAStartup(MAKEWORD(2, 0), &data);
654 case PA_CMD_DUMP_MODULES:
655 pa_dump_modules(conf, argc-d, argv+d);
659 case PA_CMD_DUMP_CONF: {
660 s = pa_daemon_conf_dump(conf);
667 case PA_CMD_DUMP_RESAMPLE_METHODS: {
670 for (i = 0; i < PA_RESAMPLER_MAX; i++)
671 if (pa_resample_method_supported(i))
672 printf("%s\n", pa_resample_method_to_string(i));
679 pa_cmdline_help(argv[0]);
683 case PA_CMD_VERSION :
684 printf(PACKAGE_NAME" "PACKAGE_VERSION"\n");
691 if (pa_pid_file_check_running(&pid, "pulseaudio") < 0)
692 pa_log_info(_("Daemon not running"));
694 pa_log_info(_("Daemon running as PID %u"), pid);
703 if (pa_pid_file_kill(SIGINT, NULL, "pulseaudio") < 0)
704 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno));
710 case PA_CMD_CLEANUP_SHM:
712 if (pa_shm_cleanup() >= 0)
718 pa_assert(conf->cmd == PA_CMD_DAEMON || conf->cmd == PA_CMD_START);
721 if (real_root && !conf->system_instance)
722 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
723 else if (!real_root && conf->system_instance) {
724 pa_log(_("Root privileges required."));
728 if (conf->cmd == PA_CMD_START && conf->system_instance) {
729 pa_log(_("--start not supported for system instances."));
733 if (conf->system_instance && !conf->disallow_exit)
734 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
736 if (conf->system_instance && !conf->disallow_module_loading)
737 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
739 if (conf->system_instance && !conf->disable_shm) {
740 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
741 conf->disable_shm = TRUE;
744 if (conf->system_instance && conf->exit_idle_time >= 0) {
745 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
746 conf->exit_idle_time = -1;
749 if (conf->cmd == PA_CMD_START) {
750 /* If we shall start PA only when it is not running yet, we
751 * first take the autospawn lock to make things
754 if ((autospawn_fd = pa_autospawn_lock_init()) < 0) {
755 pa_log("Failed to initialize autospawn lock");
759 if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
760 pa_log("Failed to acquire autospawn lock");
764 autospawn_locked = TRUE;
767 if (conf->daemonize) {
771 if (pa_stdio_acquire() < 0) {
772 pa_log(_("Failed to acquire stdio."));
777 if (pipe(daemon_pipe) < 0) {
778 pa_log(_("pipe failed: %s"), pa_cstrerror(errno));
782 if ((child = fork()) < 0) {
783 pa_log(_("fork() failed: %s"), pa_cstrerror(errno));
791 pa_assert_se(pa_close(daemon_pipe[1]) == 0);
794 if ((n = pa_loop_read(daemon_pipe[0], &retval, sizeof(retval), NULL)) != sizeof(retval)) {
797 pa_log(_("read() failed: %s"), pa_cstrerror(errno));
803 pa_log(_("Daemon startup failed."));
805 pa_log_info(_("Daemon startup successful."));
810 if (autospawn_fd >= 0) {
811 /* The lock file is unlocked from the parent, so we need
812 * to close it in the child */
814 pa_autospawn_lock_release();
815 pa_autospawn_lock_done(TRUE);
817 autospawn_locked = FALSE;
821 pa_assert_se(pa_close(daemon_pipe[0]) == 0);
825 if (conf->auto_log_target)
826 pa_log_set_target(PA_LOG_SYSLOG);
840 pa_assert_se(open("/dev/null", O_RDONLY) == 0);
841 pa_assert_se(open("/dev/null", O_WRONLY) == 1);
842 pa_assert_se(open("/dev/null", O_WRONLY) == 2);
848 signal(SIGTTOU, SIG_IGN);
851 signal(SIGTTIN, SIG_IGN);
854 signal(SIGTSTP, SIG_IGN);
858 if ((tty_fd = open("/dev/tty", O_RDWR)) >= 0) {
859 ioctl(tty_fd, TIOCNOTTY, (char*) 0);
860 pa_assert_se(pa_close(tty_fd) == 0);
865 pa_set_env("PULSE_INTERNAL", "1");
866 pa_assert_se(chdir("/") == 0);
869 if (conf->system_instance)
870 if (change_user() < 0)
873 pa_set_env("PULSE_SYSTEM", conf->system_instance ? "1" : "0");
875 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION);
876 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST);
877 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS);
879 s = pa_uname_string();
880 pa_log_debug(_("Running on host: %s"), s);
883 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
885 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE);
887 #ifdef HAVE_VALGRIND_MEMCHECK_H
888 pa_log_debug(_("Compiled with Valgrind support: yes"));
890 pa_log_debug(_("Compiled with Valgrind support: no"));
893 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
896 pa_log_debug(_("Optimized build: yes"));
898 pa_log_debug(_("Optimized build: no"));
902 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
903 #elif defined(FASTPATH)
904 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
906 pa_log_debug(_("All asserts enabled."));
909 if (!(s = pa_machine_id())) {
910 pa_log(_("Failed to get machine ID"));
913 pa_log_info(_("Machine ID is %s."), s);
916 if ((s = pa_session_id())) {
917 pa_log_info(_("Session ID is %s."), s);
921 if (!(s = pa_get_runtime_dir()))
923 pa_log_info(_("Using runtime directory %s."), s);
926 if (!(s = pa_get_state_dir()))
928 pa_log_info(_("Using state directory %s."), s);
931 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
933 if (conf->use_pid_file) {
936 if ((z = pa_pid_file_create("pulseaudio")) != 0) {
938 if (conf->cmd == PA_CMD_START && z > 0) {
939 /* If we are already running and with are run in
940 * --start mode, then let's return this as success. */
946 pa_log(_("pa_pid_file_create() failed."));
950 valid_pid_file = TRUE;
953 pa_disable_sigpipe();
955 if (pa_rtclock_hrtimer())
956 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
958 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
960 pa_rtclock_hrtimer_enable();
963 /* Valgrind uses SIGRTMAX. To easy debugging we don't use it here */
964 pa_rtsig_configure(SIGRTMIN, SIGRTMAX-1);
967 if (conf->lock_memory) {
968 #ifdef HAVE_SYS_MMAN_H
969 if (mlockall(MCL_FUTURE) < 0)
970 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno));
972 pa_log_info("Sucessfully locked process into memory.");
974 pa_log_warn("Memory locking requested but not supported on platform.");
978 pa_memtrap_install();
980 pa_assert_se(mainloop = pa_mainloop_new());
982 if (!(c = pa_core_new(pa_mainloop_get_api(mainloop), !conf->disable_shm, conf->shm_size))) {
983 pa_log(_("pa_core_new() failed."));
987 c->default_sample_spec = conf->default_sample_spec;
988 c->default_channel_map = conf->default_channel_map;
989 c->default_n_fragments = conf->default_n_fragments;
990 c->default_fragment_size_msec = conf->default_fragment_size_msec;
991 c->exit_idle_time = conf->exit_idle_time;
992 c->scache_idle_time = conf->scache_idle_time;
993 c->resample_method = conf->resample_method;
994 c->realtime_priority = conf->realtime_priority;
995 c->realtime_scheduling = !!conf->realtime_scheduling;
996 c->disable_remixing = !!conf->disable_remixing;
997 c->disable_lfe_remixing = !!conf->disable_lfe_remixing;
998 c->running_as_daemon = !!conf->daemonize;
999 c->disallow_exit = conf->disallow_exit;
1000 c->flat_volumes = conf->flat_volumes;
1002 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop)) == 0);
1003 pa_signal_new(SIGINT, signal_callback, c);
1004 pa_signal_new(SIGTERM, signal_callback, c);
1006 pa_signal_new(SIGUSR1, signal_callback, c);
1009 pa_signal_new(SIGUSR2, signal_callback, c);
1012 pa_signal_new(SIGHUP, signal_callback, c);
1016 win32_timer = pa_mainloop_get_api(mainloop)->time_new(pa_mainloop_get_api(mainloop), pa_gettimeofday(&win32_tv), message_cb, NULL);
1021 if (!conf->no_cpu_limit)
1022 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop)) == 0);
1024 buf = pa_strbuf_new();
1025 if (conf->load_default_script_file) {
1028 if ((f = pa_daemon_conf_open_default_script_file(conf))) {
1029 r = pa_cli_command_execute_file_stream(c, f, buf, &conf->fail);
1035 r = pa_cli_command_execute(c, conf->script_commands, buf, &conf->fail);
1037 pa_log_error("%s", s = pa_strbuf_tostring_free(buf));
1040 /* We completed the initial module loading, so let's disable it
1041 * from now on, if requested */
1042 c->disallow_module_loading = !!conf->disallow_module_loading;
1044 if (r < 0 && conf->fail) {
1045 pa_log(_("Failed to initialize daemon."));
1049 if (!c->modules || pa_idxset_size(c->modules) == 0) {
1050 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1055 if (daemon_pipe[1] >= 0) {
1057 pa_loop_write(daemon_pipe[1], &ok, sizeof(ok), NULL);
1058 pa_close(daemon_pipe[1]);
1059 daemon_pipe[1] = -1;
1064 dbus = register_dbus(c);
1067 pa_log_info(_("Daemon startup complete."));
1070 if (pa_mainloop_run(mainloop, &retval) < 0)
1073 pa_log_info(_("Daemon shutdown initiated."));
1078 pa_dbus_connection_unref(dbus);
1081 if (autospawn_fd >= 0) {
1082 if (autospawn_locked)
1083 pa_autospawn_lock_release();
1085 pa_autospawn_lock_done(FALSE);
1090 pa_mainloop_get_api(mainloop)->time_free(win32_timer);
1095 pa_log_info(_("Daemon terminated."));
1098 if (!conf->no_cpu_limit)
1099 pa_cpu_limit_done();
1104 if (daemon_pipe[1] >= 0)
1105 pa_loop_write(daemon_pipe[1], &retval, sizeof(retval), NULL);
1107 pa_close_pipe(daemon_pipe);
1111 pa_mainloop_free(mainloop);
1114 pa_daemon_conf_free(conf);
1117 pa_pid_file_remove();