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
59 #include <dbus/dbus.h>
62 #include <pulse/client-conf.h>
64 #include <pulse/client-conf-x11.h>
66 #include <pulse/mainloop.h>
67 #include <pulse/mainloop-signal.h>
68 #include <pulse/timeval.h>
69 #include <pulse/xmalloc.h>
70 #include <pulse/i18n.h>
72 #include <pulsecore/lock-autospawn.h>
73 #include <pulsecore/socket.h>
74 #include <pulsecore/core-error.h>
75 #include <pulsecore/core-rtclock.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/macro.h>
88 #include <pulsecore/mutex.h>
89 #include <pulsecore/thread.h>
90 #include <pulsecore/once.h>
91 #include <pulsecore/shm.h>
92 #include <pulsecore/memtrap.h>
94 #include <pulsecore/dbus-shared.h>
96 #include <pulsecore/cpu-arm.h>
97 #include <pulsecore/cpu-x86.h>
100 #include "cpulimit.h"
101 #include "daemon-conf.h"
102 #include "dumpmodules.h"
104 #include "ltdl-bind-now.h"
105 #include "server-lookup.h"
108 /* Only one instance of these variables */
109 int allow_severity
= LOG_INFO
;
110 int deny_severity
= LOG_WARNING
;
113 #ifdef HAVE_OSS_WRAPPER
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 if (!getenv("PULSE_RUNTIME_PATH"))
264 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH
);
266 if (!getenv("PULSE_CONFIG_PATH"))
267 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH
);
269 if (!getenv("PULSE_STATE_PATH"))
270 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH
);
272 pa_log_info(_("Successfully dropped root privileges."));
277 #else /* HAVE_PWD_H && HAVE_GRP_H */
279 static int change_user(void) {
280 pa_log(_("System wide mode unsupported on this platform."));
284 #endif /* HAVE_PWD_H && HAVE_GRP_H */
286 #ifdef HAVE_SYS_RESOURCE_H
288 static int set_one_rlimit(const pa_rlimit
*r
, int resource
, const char *name
) {
295 rl
.rlim_cur
= rl
.rlim_max
= r
->value
;
297 if (setrlimit(resource
, &rl
) < 0) {
298 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name
, (unsigned) r
->value
, (unsigned) r
->value
, pa_cstrerror(errno
));
305 static void set_all_rlimits(const pa_daemon_conf
*conf
) {
306 set_one_rlimit(&conf
->rlimit_fsize
, RLIMIT_FSIZE
, "RLIMIT_FSIZE");
307 set_one_rlimit(&conf
->rlimit_data
, RLIMIT_DATA
, "RLIMIT_DATA");
308 set_one_rlimit(&conf
->rlimit_stack
, RLIMIT_STACK
, "RLIMIT_STACK");
309 set_one_rlimit(&conf
->rlimit_core
, RLIMIT_CORE
, "RLIMIT_CORE");
311 set_one_rlimit(&conf
->rlimit_rss
, RLIMIT_RSS
, "RLIMIT_RSS");
314 set_one_rlimit(&conf
->rlimit_nproc
, RLIMIT_NPROC
, "RLIMIT_NPROC");
317 set_one_rlimit(&conf
->rlimit_nofile
, RLIMIT_NOFILE
, "RLIMIT_NOFILE");
319 #ifdef RLIMIT_MEMLOCK
320 set_one_rlimit(&conf
->rlimit_memlock
, RLIMIT_MEMLOCK
, "RLIMIT_MEMLOCK");
323 set_one_rlimit(&conf
->rlimit_as
, RLIMIT_AS
, "RLIMIT_AS");
326 set_one_rlimit(&conf
->rlimit_locks
, RLIMIT_LOCKS
, "RLIMIT_LOCKS");
328 #ifdef RLIMIT_SIGPENDING
329 set_one_rlimit(&conf
->rlimit_sigpending
, RLIMIT_SIGPENDING
, "RLIMIT_SIGPENDING");
331 #ifdef RLIMIT_MSGQUEUE
332 set_one_rlimit(&conf
->rlimit_msgqueue
, RLIMIT_MSGQUEUE
, "RLIMIT_MSGQUEUE");
335 set_one_rlimit(&conf
->rlimit_nice
, RLIMIT_NICE
, "RLIMIT_NICE");
338 set_one_rlimit(&conf
->rlimit_rtprio
, RLIMIT_RTPRIO
, "RLIMIT_RTPRIO");
341 set_one_rlimit(&conf
->rlimit_rttime
, RLIMIT_RTTIME
, "RLIMIT_RTTIME");
346 static char *check_configured_address(void) {
347 char *default_server
= NULL
;
348 pa_client_conf
*c
= pa_client_conf_new();
350 pa_client_conf_load(c
, NULL
);
352 pa_client_conf_from_x11(c
, NULL
);
354 pa_client_conf_env(c
);
356 if (c
->default_server
&& *c
->default_server
)
357 default_server
= pa_xstrdup(c
->default_server
);
359 pa_client_conf_free(c
);
361 return default_server
;
365 static pa_dbus_connection
*register_dbus_name(pa_core
*c
, DBusBusType bus
, const char* name
) {
367 pa_dbus_connection
*conn
;
369 dbus_error_init(&error
);
371 if (!(conn
= pa_dbus_bus_get(c
, bus
, &error
)) || dbus_error_is_set(&error
)) {
372 pa_log_warn("Unable to contact D-Bus: %s: %s", error
.name
, error
.message
);
376 if (dbus_bus_request_name(pa_dbus_connection_get(conn
), name
, DBUS_NAME_FLAG_DO_NOT_QUEUE
, &error
) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
) {
377 pa_log_debug("Got %s!", name
);
381 if (dbus_error_is_set(&error
))
382 pa_log_error("Failed to acquire %s: %s: %s", name
, error
.name
, error
.message
);
384 pa_log_error("D-Bus name %s already taken. Weird shit!", name
);
386 /* PA cannot be started twice by the same user and hence we can
387 * ignore mostly the case that a name is already taken. */
391 pa_dbus_connection_unref(conn
);
393 dbus_error_free(&error
);
398 int main(int argc
, char *argv
[]) {
400 pa_strbuf
*buf
= NULL
;
401 pa_daemon_conf
*conf
= NULL
;
402 pa_mainloop
*mainloop
= NULL
;
404 char *configured_address
;
405 int r
= 0, retval
= 1, d
= 0;
406 pa_bool_t valid_pid_file
= FALSE
;
407 pa_bool_t ltdl_init
= FALSE
;
411 int daemon_pipe
[2] = { -1, -1 };
414 pa_time_event
*win32_timer
;
415 struct timeval win32_tv
;
417 int autospawn_fd
= -1;
418 pa_bool_t autospawn_locked
= FALSE
;
420 pa_dbusobj_server_lookup
*server_lookup
= NULL
; /* /org/pulseaudio/server_lookup */
421 pa_dbus_connection
*lookup_service_bus
= NULL
; /* Always the user bus. */
422 pa_dbus_connection
*server_bus
= NULL
; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
423 pa_bool_t start_server
;
426 pa_log_set_ident("pulseaudio");
427 pa_log_set_level(PA_LOG_NOTICE
);
428 pa_log_set_flags(PA_LOG_COLORS
|PA_LOG_PRINT_FILE
|PA_LOG_PRINT_LEVEL
, PA_LOG_RESET
);
430 #if defined(__linux__) && defined(__OPTIMIZE__)
432 Disable lazy relocations to make usage of external libraries
433 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
434 a check whether we are a debug build or not. This all is
435 admittedly a bit snake-oilish.
438 if (!getenv("LD_BIND_NOW")) {
442 /* We have to execute ourselves, because the libc caches the
443 * value of $LD_BIND_NOW on initialization. */
445 pa_set_env("LD_BIND_NOW", "1");
447 if ((canonical_rp
= pa_realpath(PA_BINARY
))) {
449 if ((rp
= pa_readlink("/proc/self/exe"))) {
451 if (pa_streq(rp
, canonical_rp
))
452 pa_assert_se(execv(rp
, argv
) == 0);
454 pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp
);
459 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
461 pa_xfree(canonical_rp
);
464 pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
468 if ((e
= getenv("PULSE_PASSED_FD"))) {
475 /* We might be autospawned, in which case have no idea in which
476 * context we have been started. Let's cleanup our execution
477 * context as good as possible */
479 pa_reset_personality();
481 pa_close_all(passed_fd
, -1);
486 setlocale(LC_ALL
, "");
489 conf
= pa_daemon_conf_new();
491 if (pa_daemon_conf_load(conf
, NULL
) < 0)
494 if (pa_daemon_conf_env(conf
) < 0)
497 if (pa_cmdline_parse(conf
, argc
, argv
, &d
) < 0) {
498 pa_log(_("Failed to parse command line."));
502 pa_log_set_level(conf
->log_level
);
503 pa_log_set_target(conf
->auto_log_target
? PA_LOG_STDERR
: conf
->log_target
);
505 pa_log_set_flags(PA_LOG_PRINT_META
, PA_LOG_SET
);
507 pa_log_set_flags(PA_LOG_PRINT_TIME
, PA_LOG_SET
);
508 pa_log_set_show_backtrace(conf
->log_backtrace
);
511 /* conf->system_instance and conf->local_server_type control almost the
512 * same thing; make them agree about what is requested. */
513 switch (conf
->local_server_type
) {
514 case PA_SERVER_TYPE_UNSET
:
515 conf
->local_server_type
= conf
->system_instance
? PA_SERVER_TYPE_SYSTEM
: PA_SERVER_TYPE_USER
;
517 case PA_SERVER_TYPE_USER
:
518 case PA_SERVER_TYPE_NONE
:
519 conf
->system_instance
= FALSE
;
521 case PA_SERVER_TYPE_SYSTEM
:
522 conf
->system_instance
= TRUE
;
525 pa_assert_not_reached();
528 start_server
= conf
->local_server_type
== PA_SERVER_TYPE_USER
|| (getuid() == 0 && conf
->local_server_type
== PA_SERVER_TYPE_SYSTEM
);
530 if (!start_server
&& conf
->local_server_type
== PA_SERVER_TYPE_SYSTEM
) {
531 pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
532 conf
->system_instance
= FALSE
;
536 LTDL_SET_PRELOADED_SYMBOLS();
540 if (conf
->dl_search_path
)
541 lt_dlsetsearchpath(conf
->dl_search_path
);
546 WSAStartup(MAKEWORD(2, 0), &data
);
553 case PA_CMD_DUMP_MODULES
:
554 pa_dump_modules(conf
, argc
-d
, argv
+d
);
558 case PA_CMD_DUMP_CONF
: {
561 pa_log("Too many arguments.\n");
565 s
= pa_daemon_conf_dump(conf
);
572 case PA_CMD_DUMP_RESAMPLE_METHODS
: {
576 pa_log("Too many arguments.\n");
580 for (i
= 0; i
< PA_RESAMPLER_MAX
; i
++)
581 if (pa_resample_method_supported(i
))
582 printf("%s\n", pa_resample_method_to_string(i
));
589 pa_cmdline_help(argv
[0]);
593 case PA_CMD_VERSION
:
596 pa_log("Too many arguments.\n");
600 printf(PACKAGE_NAME
" "PACKAGE_VERSION
"\n");
608 pa_log("Too many arguments.\n");
612 if (pa_pid_file_check_running(&pid
, "pulseaudio") < 0)
613 pa_log_info(_("Daemon not running"));
615 pa_log_info(_("Daemon running as PID %u"), pid
);
625 pa_log("Too many arguments.\n");
629 if (pa_pid_file_kill(SIGINT
, NULL
, "pulseaudio") < 0)
630 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno
));
636 case PA_CMD_CLEANUP_SHM
:
639 pa_log("Too many arguments.\n");
643 if (pa_shm_cleanup() >= 0)
649 pa_assert(conf
->cmd
== PA_CMD_DAEMON
|| conf
->cmd
== PA_CMD_START
);
653 pa_log("Too many arguments.\n");
658 if (getuid() == 0 && !conf
->system_instance
)
659 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
660 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
661 else if (getuid() != 0 && conf
->system_instance
) {
662 pa_log(_("Root privileges required."));
666 #endif /* HAVE_GETUID */
668 if (conf
->cmd
== PA_CMD_START
&& conf
->system_instance
) {
669 pa_log(_("--start not supported for system instances."));
673 if (conf
->cmd
== PA_CMD_START
&& (configured_address
= check_configured_address())) {
674 pa_log_notice(_("User-configured server at %s, not autospawning."), configured_address
);
675 pa_xfree(configured_address
);
680 if (conf
->system_instance
&& !conf
->disallow_exit
)
681 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
683 if (conf
->system_instance
&& !conf
->disallow_module_loading
)
684 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
686 if (conf
->system_instance
&& !conf
->disable_shm
) {
687 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
688 conf
->disable_shm
= TRUE
;
691 if (conf
->system_instance
&& conf
->exit_idle_time
>= 0) {
692 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
693 conf
->exit_idle_time
= -1;
696 if (conf
->cmd
== PA_CMD_START
) {
697 /* If we shall start PA only when it is not running yet, we
698 * first take the autospawn lock to make things
701 if ((autospawn_fd
= pa_autospawn_lock_init()) < 0) {
702 pa_log("Failed to initialize autospawn lock");
706 if ((pa_autospawn_lock_acquire(TRUE
) < 0)) {
707 pa_log("Failed to acquire autospawn lock");
711 autospawn_locked
= TRUE
;
714 if (conf
->daemonize
) {
717 if (pa_stdio_acquire() < 0) {
718 pa_log(_("Failed to acquire stdio."));
723 if (pipe(daemon_pipe
) < 0) {
724 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno
));
728 if ((child
= fork()) < 0) {
729 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
737 pa_assert_se(pa_close(daemon_pipe
[1]) == 0);
740 if ((n
= pa_loop_read(daemon_pipe
[0], &retval
, sizeof(retval
), NULL
)) != sizeof(retval
)) {
743 pa_log(_("read() failed: %s"), pa_cstrerror(errno
));
749 pa_log(_("Daemon startup failed."));
751 pa_log_info(_("Daemon startup successful."));
756 if (autospawn_fd
>= 0) {
757 /* The lock file is unlocked from the parent, so we need
758 * to close it in the child */
760 pa_autospawn_lock_release();
761 pa_autospawn_lock_done(TRUE
);
763 autospawn_locked
= FALSE
;
767 pa_assert_se(pa_close(daemon_pipe
[0]) == 0);
771 if (conf
->auto_log_target
)
772 pa_log_set_target(PA_LOG_SYSLOG
);
776 pa_log(_("setsid() failed: %s"), pa_cstrerror(errno
));
781 /* We now are a session and process group leader. Let's fork
782 * again and let the father die, so that we'll become a
783 * process that can never acquire a TTY again, in a session and
784 * process group without leader */
787 if ((child
= fork()) < 0) {
788 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
799 signal(SIGTTOU
, SIG_IGN
);
802 signal(SIGTTIN
, SIG_IGN
);
805 signal(SIGTSTP
, SIG_IGN
);
811 pa_set_env_and_record("PULSE_INTERNAL", "1");
812 pa_assert_se(chdir("/") == 0);
815 #ifdef HAVE_SYS_RESOURCE_H
816 set_all_rlimits(conf
);
818 pa_rtclock_hrtimer_enable();
820 pa_raise_priority(conf
->nice_level
);
822 if (conf
->system_instance
)
823 if (change_user() < 0)
826 pa_set_env_and_record("PULSE_SYSTEM", conf
->system_instance
? "1" : "0");
828 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION
);
829 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST
);
830 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS
);
832 s
= pa_uname_string();
833 pa_log_debug(_("Running on host: %s"), s
);
836 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
838 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE
);
840 #ifdef HAVE_VALGRIND_MEMCHECK_H
841 pa_log_debug(_("Compiled with Valgrind support: yes"));
843 pa_log_debug(_("Compiled with Valgrind support: no"));
846 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
848 pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
851 pa_log_debug(_("Optimized build: yes"));
853 pa_log_debug(_("Optimized build: no"));
857 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
858 #elif defined(FASTPATH)
859 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
861 pa_log_debug(_("All asserts enabled."));
864 if (!(s
= pa_machine_id())) {
865 pa_log(_("Failed to get machine ID"));
868 pa_log_info(_("Machine ID is %s."), s
);
871 if ((s
= pa_session_id())) {
872 pa_log_info(_("Session ID is %s."), s
);
876 if (!(s
= pa_get_runtime_dir()))
878 pa_log_info(_("Using runtime directory %s."), s
);
881 if (!(s
= pa_get_state_dir()))
883 pa_log_info(_("Using state directory %s."), s
);
886 pa_log_info(_("Using modules directory %s."), conf
->dl_search_path
);
888 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
890 if (pa_in_system_mode())
891 pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
892 "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
893 "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
895 if (conf
->use_pid_file
) {
898 if ((z
= pa_pid_file_create("pulseaudio")) != 0) {
900 if (conf
->cmd
== PA_CMD_START
&& z
> 0) {
901 /* If we are already running and with are run in
902 * --start mode, then let's return this as success. */
908 pa_log(_("pa_pid_file_create() failed."));
912 valid_pid_file
= TRUE
;
915 pa_disable_sigpipe();
917 if (pa_rtclock_hrtimer())
918 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
920 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
922 if (conf
->lock_memory
) {
923 #ifdef HAVE_SYS_MMAN_H
924 if (mlockall(MCL_FUTURE
) < 0)
925 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno
));
927 pa_log_info("Successfully locked process into memory.");
929 pa_log_warn("Memory locking requested but not supported on platform.");
933 pa_memtrap_install();
935 pa_assert_se(mainloop
= pa_mainloop_new());
937 if (!(c
= pa_core_new(pa_mainloop_get_api(mainloop
), !conf
->disable_shm
, conf
->shm_size
))) {
938 pa_log(_("pa_core_new() failed."));
942 c
->default_sample_spec
= conf
->default_sample_spec
;
943 c
->default_channel_map
= conf
->default_channel_map
;
944 c
->default_n_fragments
= conf
->default_n_fragments
;
945 c
->default_fragment_size_msec
= conf
->default_fragment_size_msec
;
946 c
->sync_volume_safety_margin_usec
= conf
->sync_volume_safety_margin_usec
;
947 c
->sync_volume_extra_delay_usec
= conf
->sync_volume_extra_delay_usec
;
948 c
->exit_idle_time
= conf
->exit_idle_time
;
949 c
->scache_idle_time
= conf
->scache_idle_time
;
950 c
->resample_method
= conf
->resample_method
;
951 c
->realtime_priority
= conf
->realtime_priority
;
952 c
->realtime_scheduling
= !!conf
->realtime_scheduling
;
953 c
->disable_remixing
= !!conf
->disable_remixing
;
954 c
->disable_lfe_remixing
= !!conf
->disable_lfe_remixing
;
955 c
->sync_volume
= !!conf
->sync_volume
;
956 c
->running_as_daemon
= !!conf
->daemonize
;
957 c
->disallow_exit
= conf
->disallow_exit
;
958 c
->flat_volumes
= conf
->flat_volumes
;
960 c
->server_type
= conf
->local_server_type
;
963 c
->cpu_info
.cpu_type
= PA_CPU_UNDEFINED
;
964 if (!getenv("PULSE_NO_SIMD")) {
965 if (pa_cpu_init_x86(&(c
->cpu_info
.flags
.x86
)))
966 c
->cpu_info
.cpu_type
= PA_CPU_X86
;
967 if (pa_cpu_init_arm(&(c
->cpu_info
.flags
.arm
)))
968 c
->cpu_info
.cpu_type
= PA_CPU_ARM
;
971 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop
)) == 0);
972 pa_signal_new(SIGINT
, signal_callback
, c
);
973 pa_signal_new(SIGTERM
, signal_callback
, c
);
975 pa_signal_new(SIGUSR1
, signal_callback
, c
);
978 pa_signal_new(SIGUSR2
, signal_callback
, c
);
981 pa_signal_new(SIGHUP
, signal_callback
, c
);
985 win32_timer
= pa_mainloop_get_api(mainloop
)->time_new(pa_mainloop_get_api(mainloop
), pa_gettimeofday(&win32_tv
), message_cb
, NULL
);
988 if (!conf
->no_cpu_limit
)
989 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop
)) == 0);
991 buf
= pa_strbuf_new();
996 if (conf
->load_default_script_file
) {
999 if ((f
= pa_daemon_conf_open_default_script_file(conf
))) {
1000 r
= pa_cli_command_execute_file_stream(c
, f
, buf
, &conf
->fail
);
1006 r
= pa_cli_command_execute(c
, conf
->script_commands
, buf
, &conf
->fail
);
1008 pa_log_error("%s", s
= pa_strbuf_tostring_free(buf
));
1011 if (r
< 0 && conf
->fail
) {
1012 pa_log(_("Failed to initialize daemon."));
1016 if (!c
->modules
|| pa_idxset_size(c
->modules
) == 0) {
1017 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1022 /* When we just provide the D-Bus server lookup service, we don't want
1023 * any modules to be loaded. We haven't loaded any so far, so one might
1024 * think there's no way to contact the server, but receiving certain
1025 * signals could still cause modules to load. */
1026 conf
->disallow_module_loading
= TRUE
;
1030 /* We completed the initial module loading, so let's disable it
1031 * from now on, if requested */
1032 c
->disallow_module_loading
= !!conf
->disallow_module_loading
;
1035 if (!conf
->system_instance
) {
1036 if (!(server_lookup
= pa_dbusobj_server_lookup_new(c
)))
1038 if (!(lookup_service_bus
= register_dbus_name(c
, DBUS_BUS_SESSION
, "org.PulseAudio1")))
1042 if (start_server
&& !(server_bus
= register_dbus_name(c
, conf
->system_instance
? DBUS_BUS_SYSTEM
: DBUS_BUS_SESSION
, "org.pulseaudio.Server")))
1047 if (daemon_pipe
[1] >= 0) {
1049 pa_loop_write(daemon_pipe
[1], &ok
, sizeof(ok
), NULL
);
1050 pa_close(daemon_pipe
[1]);
1051 daemon_pipe
[1] = -1;
1055 pa_log_info(_("Daemon startup complete."));
1058 if (pa_mainloop_run(mainloop
, &retval
) < 0)
1061 pa_log_info(_("Daemon shutdown initiated."));
1066 pa_dbus_connection_unref(server_bus
);
1067 if (lookup_service_bus
)
1068 pa_dbus_connection_unref(lookup_service_bus
);
1070 pa_dbusobj_server_lookup_free(server_lookup
);
1073 if (autospawn_fd
>= 0) {
1074 if (autospawn_locked
)
1075 pa_autospawn_lock_release();
1077 pa_autospawn_lock_done(FALSE
);
1082 pa_mainloop_get_api(mainloop
)->time_free(win32_timer
);
1087 pa_log_info(_("Daemon terminated."));
1090 if (!conf
->no_cpu_limit
)
1091 pa_cpu_limit_done();
1096 if (daemon_pipe
[1] >= 0)
1097 pa_loop_write(daemon_pipe
[1], &retval
, sizeof(retval
), NULL
);
1099 pa_close_pipe(daemon_pipe
);
1103 pa_mainloop_free(mainloop
);
1106 pa_daemon_conf_free(conf
);
1109 pa_pid_file_remove();
1111 /* This has no real purpose except making things valgrind-clean */
1112 pa_unset_env_recorded();