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>
98 #include <pulsecore/cpu-orc.h>
101 #include "cpulimit.h"
102 #include "daemon-conf.h"
103 #include "dumpmodules.h"
105 #include "ltdl-bind-now.h"
106 #include "server-lookup.h"
109 /* Only one instance of these variables */
110 int allow_severity
= LOG_INFO
;
111 int deny_severity
= LOG_WARNING
;
114 #ifdef HAVE_OSS_WRAPPER
115 /* padsp looks for this symbol in the running process and disables
116 * itself if it finds it and it is set to 7 (which is actually a bit
117 * mask). For details see padsp. */
118 int __padsp_disabled__
= 7;
123 static void message_cb(pa_mainloop_api
*a
, pa_time_event
*e
, const struct timeval
*tv
, void *userdata
) {
125 struct timeval tvnext
;
127 while (PeekMessage(&msg
, NULL
, 0, 0, PM_REMOVE
)) {
128 if (msg
.message
== WM_QUIT
)
131 TranslateMessage(&msg
);
132 DispatchMessage(&msg
);
136 pa_timeval_add(pa_gettimeofday(&tvnext
), 100000);
137 a
->time_restart(e
, &tvnext
);
142 static void signal_callback(pa_mainloop_api
*m
, pa_signal_event
*e
, int sig
, void *userdata
) {
143 pa_log_info(_("Got signal %s."), pa_sig2str(sig
));
148 pa_module_load(userdata
, "module-cli", NULL
);
154 pa_module_load(userdata
, "module-cli-protocol-unix", NULL
);
160 char *c
= pa_full_status_string(userdata
);
161 pa_log_notice("%s", c
);
170 pa_log_info(_("Exiting."));
176 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
178 static int change_user(void) {
183 /* This function is called only in system-wide mode. It creates a
184 * runtime dir in /var/run/ with proper UID/GID and drops privs
187 if (!(pw
= getpwnam(PA_SYSTEM_USER
))) {
188 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER
);
192 if (!(gr
= getgrnam(PA_SYSTEM_GROUP
))) {
193 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP
);
197 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
198 PA_SYSTEM_USER
, (unsigned long) pw
->pw_uid
,
199 PA_SYSTEM_GROUP
, (unsigned long) gr
->gr_gid
);
201 if (pw
->pw_gid
!= gr
->gr_gid
) {
202 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER
, PA_SYSTEM_GROUP
);
206 if (strcmp(pw
->pw_dir
, PA_SYSTEM_RUNTIME_PATH
) != 0)
207 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER
, PA_SYSTEM_RUNTIME_PATH
);
209 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH
, 0755, pw
->pw_uid
, gr
->gr_gid
) < 0) {
210 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH
, pa_cstrerror(errno
));
214 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH
, 0700, pw
->pw_uid
, gr
->gr_gid
) < 0) {
215 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH
, pa_cstrerror(errno
));
219 /* We don't create the config dir here, because we don't need to write to it */
221 if (initgroups(PA_SYSTEM_USER
, gr
->gr_gid
) != 0) {
222 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno
));
226 #if defined(HAVE_SETRESGID)
227 r
= setresgid(gr
->gr_gid
, gr
->gr_gid
, gr
->gr_gid
);
228 #elif defined(HAVE_SETEGID)
229 if ((r
= setgid(gr
->gr_gid
)) >= 0)
230 r
= setegid(gr
->gr_gid
);
231 #elif defined(HAVE_SETREGID)
232 r
= setregid(gr
->gr_gid
, gr
->gr_gid
);
234 #error "No API to drop privileges"
238 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno
));
242 #if defined(HAVE_SETRESUID)
243 r
= setresuid(pw
->pw_uid
, pw
->pw_uid
, pw
->pw_uid
);
244 #elif defined(HAVE_SETEUID)
245 if ((r
= setuid(pw
->pw_uid
)) >= 0)
246 r
= seteuid(pw
->pw_uid
);
247 #elif defined(HAVE_SETREUID)
248 r
= setreuid(pw
->pw_uid
, pw
->pw_uid
);
250 #error "No API to drop privileges"
254 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno
));
258 pa_set_env("USER", PA_SYSTEM_USER
);
259 pa_set_env("USERNAME", PA_SYSTEM_USER
);
260 pa_set_env("LOGNAME", PA_SYSTEM_USER
);
261 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH
);
263 /* Relevant for pa_runtime_path() */
264 if (!getenv("PULSE_RUNTIME_PATH"))
265 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH
);
267 if (!getenv("PULSE_CONFIG_PATH"))
268 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH
);
270 if (!getenv("PULSE_STATE_PATH"))
271 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH
);
273 pa_log_info(_("Successfully dropped root privileges."));
278 #else /* HAVE_PWD_H && HAVE_GRP_H */
280 static int change_user(void) {
281 pa_log(_("System wide mode unsupported on this platform."));
285 #endif /* HAVE_PWD_H && HAVE_GRP_H */
287 #ifdef HAVE_SYS_RESOURCE_H
289 static int set_one_rlimit(const pa_rlimit
*r
, int resource
, const char *name
) {
296 rl
.rlim_cur
= rl
.rlim_max
= r
->value
;
298 if (setrlimit(resource
, &rl
) < 0) {
299 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name
, (unsigned) r
->value
, (unsigned) r
->value
, pa_cstrerror(errno
));
306 static void set_all_rlimits(const pa_daemon_conf
*conf
) {
307 set_one_rlimit(&conf
->rlimit_fsize
, RLIMIT_FSIZE
, "RLIMIT_FSIZE");
308 set_one_rlimit(&conf
->rlimit_data
, RLIMIT_DATA
, "RLIMIT_DATA");
309 set_one_rlimit(&conf
->rlimit_stack
, RLIMIT_STACK
, "RLIMIT_STACK");
310 set_one_rlimit(&conf
->rlimit_core
, RLIMIT_CORE
, "RLIMIT_CORE");
312 set_one_rlimit(&conf
->rlimit_rss
, RLIMIT_RSS
, "RLIMIT_RSS");
315 set_one_rlimit(&conf
->rlimit_nproc
, RLIMIT_NPROC
, "RLIMIT_NPROC");
318 set_one_rlimit(&conf
->rlimit_nofile
, RLIMIT_NOFILE
, "RLIMIT_NOFILE");
320 #ifdef RLIMIT_MEMLOCK
321 set_one_rlimit(&conf
->rlimit_memlock
, RLIMIT_MEMLOCK
, "RLIMIT_MEMLOCK");
324 set_one_rlimit(&conf
->rlimit_as
, RLIMIT_AS
, "RLIMIT_AS");
327 set_one_rlimit(&conf
->rlimit_locks
, RLIMIT_LOCKS
, "RLIMIT_LOCKS");
329 #ifdef RLIMIT_SIGPENDING
330 set_one_rlimit(&conf
->rlimit_sigpending
, RLIMIT_SIGPENDING
, "RLIMIT_SIGPENDING");
332 #ifdef RLIMIT_MSGQUEUE
333 set_one_rlimit(&conf
->rlimit_msgqueue
, RLIMIT_MSGQUEUE
, "RLIMIT_MSGQUEUE");
336 set_one_rlimit(&conf
->rlimit_nice
, RLIMIT_NICE
, "RLIMIT_NICE");
339 set_one_rlimit(&conf
->rlimit_rtprio
, RLIMIT_RTPRIO
, "RLIMIT_RTPRIO");
342 set_one_rlimit(&conf
->rlimit_rttime
, RLIMIT_RTTIME
, "RLIMIT_RTTIME");
347 static char *check_configured_address(void) {
348 char *default_server
= NULL
;
349 pa_client_conf
*c
= pa_client_conf_new();
351 pa_client_conf_load(c
, NULL
);
353 pa_client_conf_from_x11(c
, NULL
);
355 pa_client_conf_env(c
);
357 if (c
->default_server
&& *c
->default_server
)
358 default_server
= pa_xstrdup(c
->default_server
);
360 pa_client_conf_free(c
);
362 return default_server
;
366 static pa_dbus_connection
*register_dbus_name(pa_core
*c
, DBusBusType bus
, const char* name
) {
368 pa_dbus_connection
*conn
;
370 dbus_error_init(&error
);
372 if (!(conn
= pa_dbus_bus_get(c
, bus
, &error
)) || dbus_error_is_set(&error
)) {
373 pa_log_warn("Unable to contact D-Bus: %s: %s", error
.name
, error
.message
);
377 if (dbus_bus_request_name(pa_dbus_connection_get(conn
), name
, DBUS_NAME_FLAG_DO_NOT_QUEUE
, &error
) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
) {
378 pa_log_debug("Got %s!", name
);
382 if (dbus_error_is_set(&error
))
383 pa_log_error("Failed to acquire %s: %s: %s", name
, error
.name
, error
.message
);
385 pa_log_error("D-Bus name %s already taken. Weird shit!", name
);
387 /* PA cannot be started twice by the same user and hence we can
388 * ignore mostly the case that a name is already taken. */
392 pa_dbus_connection_unref(conn
);
394 dbus_error_free(&error
);
399 int main(int argc
, char *argv
[]) {
401 pa_strbuf
*buf
= NULL
;
402 pa_daemon_conf
*conf
= NULL
;
403 pa_mainloop
*mainloop
= NULL
;
405 char *configured_address
;
406 int r
= 0, retval
= 1, d
= 0;
407 pa_bool_t valid_pid_file
= FALSE
;
408 pa_bool_t ltdl_init
= FALSE
;
412 int daemon_pipe
[2] = { -1, -1 };
413 int daemon_pipe2
[2] = { -1, -1 };
416 pa_time_event
*win32_timer
;
417 struct timeval win32_tv
;
419 int autospawn_fd
= -1;
420 pa_bool_t autospawn_locked
= FALSE
;
422 pa_dbusobj_server_lookup
*server_lookup
= NULL
; /* /org/pulseaudio/server_lookup */
423 pa_dbus_connection
*lookup_service_bus
= NULL
; /* Always the user bus. */
424 pa_dbus_connection
*server_bus
= NULL
; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
425 pa_bool_t start_server
;
428 pa_log_set_ident("pulseaudio");
429 pa_log_set_level(PA_LOG_NOTICE
);
430 pa_log_set_flags(PA_LOG_COLORS
|PA_LOG_PRINT_FILE
|PA_LOG_PRINT_LEVEL
, PA_LOG_RESET
);
432 #if defined(__linux__) && defined(__OPTIMIZE__)
434 Disable lazy relocations to make usage of external libraries
435 more deterministic for our RT threads. We abuse __OPTIMIZE__ as
436 a check whether we are a debug build or not. This all is
437 admittedly a bit snake-oilish.
440 if (!getenv("LD_BIND_NOW")) {
444 /* We have to execute ourselves, because the libc caches the
445 * value of $LD_BIND_NOW on initialization. */
447 pa_set_env("LD_BIND_NOW", "1");
449 if ((canonical_rp
= pa_realpath(PA_BINARY
))) {
451 if ((rp
= pa_readlink("/proc/self/exe"))) {
453 if (pa_streq(rp
, canonical_rp
))
454 pa_assert_se(execv(rp
, argv
) == 0);
456 pa_log_warn("/proc/self/exe does not point to %s, cannot self execute. Are you playing games?", canonical_rp
);
461 pa_log_warn("Couldn't read /proc/self/exe, cannot self execute. Running in a chroot()?");
463 pa_xfree(canonical_rp
);
466 pa_log_warn("Couldn't canonicalize binary path, cannot self execute.");
470 if ((e
= getenv("PULSE_PASSED_FD"))) {
477 /* We might be autospawned, in which case have no idea in which
478 * context we have been started. Let's cleanup our execution
479 * context as good as possible */
481 pa_reset_personality();
483 pa_close_all(passed_fd
, -1);
488 setlocale(LC_ALL
, "");
491 conf
= pa_daemon_conf_new();
493 if (pa_daemon_conf_load(conf
, NULL
) < 0)
496 if (pa_daemon_conf_env(conf
) < 0)
499 if (pa_cmdline_parse(conf
, argc
, argv
, &d
) < 0) {
500 pa_log(_("Failed to parse command line."));
504 pa_log_set_level(conf
->log_level
);
505 pa_log_set_target(conf
->auto_log_target
? PA_LOG_STDERR
: conf
->log_target
);
507 pa_log_set_flags(PA_LOG_PRINT_META
, PA_LOG_SET
);
509 pa_log_set_flags(PA_LOG_PRINT_TIME
, PA_LOG_SET
);
510 pa_log_set_show_backtrace(conf
->log_backtrace
);
513 /* conf->system_instance and conf->local_server_type control almost the
514 * same thing; make them agree about what is requested. */
515 switch (conf
->local_server_type
) {
516 case PA_SERVER_TYPE_UNSET
:
517 conf
->local_server_type
= conf
->system_instance
? PA_SERVER_TYPE_SYSTEM
: PA_SERVER_TYPE_USER
;
519 case PA_SERVER_TYPE_USER
:
520 case PA_SERVER_TYPE_NONE
:
521 conf
->system_instance
= FALSE
;
523 case PA_SERVER_TYPE_SYSTEM
:
524 conf
->system_instance
= TRUE
;
527 pa_assert_not_reached();
530 start_server
= conf
->local_server_type
== PA_SERVER_TYPE_USER
|| (getuid() == 0 && conf
->local_server_type
== PA_SERVER_TYPE_SYSTEM
);
532 if (!start_server
&& conf
->local_server_type
== PA_SERVER_TYPE_SYSTEM
) {
533 pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
534 conf
->system_instance
= FALSE
;
538 LTDL_SET_PRELOADED_SYMBOLS();
542 if (conf
->dl_search_path
)
543 lt_dlsetsearchpath(conf
->dl_search_path
);
548 WSAStartup(MAKEWORD(2, 0), &data
);
555 case PA_CMD_DUMP_MODULES
:
556 pa_dump_modules(conf
, argc
-d
, argv
+d
);
560 case PA_CMD_DUMP_CONF
: {
563 pa_log("Too many arguments.\n");
567 s
= pa_daemon_conf_dump(conf
);
574 case PA_CMD_DUMP_RESAMPLE_METHODS
: {
578 pa_log("Too many arguments.\n");
582 for (i
= 0; i
< PA_RESAMPLER_MAX
; i
++)
583 if (pa_resample_method_supported(i
))
584 printf("%s\n", pa_resample_method_to_string(i
));
591 pa_cmdline_help(argv
[0]);
595 case PA_CMD_VERSION
:
598 pa_log("Too many arguments.\n");
602 printf(PACKAGE_NAME
" "PACKAGE_VERSION
"\n");
610 pa_log("Too many arguments.\n");
614 if (pa_pid_file_check_running(&pid
, "pulseaudio") < 0)
615 pa_log_info(_("Daemon not running"));
617 pa_log_info(_("Daemon running as PID %u"), pid
);
627 pa_log("Too many arguments.\n");
631 if (pa_pid_file_kill(SIGINT
, NULL
, "pulseaudio") < 0)
632 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno
));
638 case PA_CMD_CLEANUP_SHM
:
641 pa_log("Too many arguments.\n");
645 if (pa_shm_cleanup() >= 0)
651 pa_assert(conf
->cmd
== PA_CMD_DAEMON
|| conf
->cmd
== PA_CMD_START
);
655 pa_log("Too many arguments.\n");
660 if (getuid() == 0 && !conf
->system_instance
)
661 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
662 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
663 else if (getuid() != 0 && conf
->system_instance
) {
664 pa_log(_("Root privileges required."));
668 #endif /* HAVE_GETUID */
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
));
784 /* We now are a session and process group leader. Let's fork
785 * again and let the father die, so that we'll become a
786 * process that can never acquire a TTY again, in a session and
787 * process group without leader */
789 if (pipe(daemon_pipe2
) < 0) {
790 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno
));
794 if ((child
= fork()) < 0) {
795 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
803 pa_assert_se(pa_close(daemon_pipe2
[1]) == 0);
804 daemon_pipe2
[1] = -1;
806 if ((n
= pa_loop_read(daemon_pipe2
[0], &retval
, sizeof(retval
), NULL
)) != sizeof(retval
)) {
809 pa_log(_("read() failed: %s"), pa_cstrerror(errno
));
814 /* We now have to take care of signalling the first fork with
815 * the return value we've received from this fork... */
816 pa_assert(daemon_pipe
[1] >= 0);
818 pa_loop_write(daemon_pipe
[1], &retval
, sizeof(retval
), NULL
);
819 pa_close(daemon_pipe
[1]);
825 pa_assert_se(pa_close(daemon_pipe2
[0]) == 0);
826 daemon_pipe2
[0] = -1;
828 /* We no longer need the (first) daemon_pipe as it's handled in our child above */
829 pa_close_pipe(daemon_pipe
);
833 signal(SIGTTOU
, SIG_IGN
);
836 signal(SIGTTIN
, SIG_IGN
);
839 signal(SIGTSTP
, SIG_IGN
);
845 pa_set_env_and_record("PULSE_INTERNAL", "1");
846 pa_assert_se(chdir("/") == 0);
849 #ifdef HAVE_SYS_RESOURCE_H
850 set_all_rlimits(conf
);
852 pa_rtclock_hrtimer_enable();
854 pa_raise_priority(conf
->nice_level
);
856 if (conf
->system_instance
)
857 if (change_user() < 0)
860 pa_set_env_and_record("PULSE_SYSTEM", conf
->system_instance
? "1" : "0");
862 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION
);
863 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST
);
864 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS
);
866 s
= pa_uname_string();
867 pa_log_debug(_("Running on host: %s"), s
);
870 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
872 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE
);
874 #ifdef HAVE_VALGRIND_MEMCHECK_H
875 pa_log_debug(_("Compiled with Valgrind support: yes"));
877 pa_log_debug(_("Compiled with Valgrind support: no"));
880 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
882 pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
885 pa_log_debug(_("Optimized build: yes"));
887 pa_log_debug(_("Optimized build: no"));
891 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
892 #elif defined(FASTPATH)
893 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
895 pa_log_debug(_("All asserts enabled."));
898 if (!(s
= pa_machine_id())) {
899 pa_log(_("Failed to get machine ID"));
902 pa_log_info(_("Machine ID is %s."), s
);
905 if ((s
= pa_session_id())) {
906 pa_log_info(_("Session ID is %s."), s
);
910 if (!(s
= pa_get_runtime_dir()))
912 pa_log_info(_("Using runtime directory %s."), s
);
915 if (!(s
= pa_get_state_dir()))
917 pa_log_info(_("Using state directory %s."), s
);
920 pa_log_info(_("Using modules directory %s."), conf
->dl_search_path
);
922 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
924 if (pa_in_system_mode())
925 pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
926 "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
927 "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
929 if (conf
->use_pid_file
) {
932 if ((z
= pa_pid_file_create("pulseaudio")) != 0) {
934 if (conf
->cmd
== PA_CMD_START
&& z
> 0) {
935 /* If we are already running and with are run in
936 * --start mode, then let's return this as success. */
942 pa_log(_("pa_pid_file_create() failed."));
946 valid_pid_file
= TRUE
;
949 pa_disable_sigpipe();
951 if (pa_rtclock_hrtimer())
952 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
954 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
956 if (conf
->lock_memory
) {
957 #ifdef HAVE_SYS_MMAN_H
958 if (mlockall(MCL_FUTURE
) < 0)
959 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno
));
961 pa_log_info("Successfully locked process into memory.");
963 pa_log_warn("Memory locking requested but not supported on platform.");
967 pa_memtrap_install();
969 pa_assert_se(mainloop
= pa_mainloop_new());
971 if (!(c
= pa_core_new(pa_mainloop_get_api(mainloop
), !conf
->disable_shm
, conf
->shm_size
))) {
972 pa_log(_("pa_core_new() failed."));
976 c
->default_sample_spec
= conf
->default_sample_spec
;
977 c
->default_channel_map
= conf
->default_channel_map
;
978 c
->default_n_fragments
= conf
->default_n_fragments
;
979 c
->default_fragment_size_msec
= conf
->default_fragment_size_msec
;
980 c
->sync_volume_safety_margin_usec
= conf
->sync_volume_safety_margin_usec
;
981 c
->sync_volume_extra_delay_usec
= conf
->sync_volume_extra_delay_usec
;
982 c
->exit_idle_time
= conf
->exit_idle_time
;
983 c
->scache_idle_time
= conf
->scache_idle_time
;
984 c
->resample_method
= conf
->resample_method
;
985 c
->realtime_priority
= conf
->realtime_priority
;
986 c
->realtime_scheduling
= !!conf
->realtime_scheduling
;
987 c
->disable_remixing
= !!conf
->disable_remixing
;
988 c
->disable_lfe_remixing
= !!conf
->disable_lfe_remixing
;
989 c
->sync_volume
= !!conf
->sync_volume
;
990 c
->running_as_daemon
= !!conf
->daemonize
;
991 c
->disallow_exit
= conf
->disallow_exit
;
992 c
->flat_volumes
= conf
->flat_volumes
;
994 c
->server_type
= conf
->local_server_type
;
997 c
->cpu_info
.cpu_type
= PA_CPU_UNDEFINED
;
998 if (!getenv("PULSE_NO_SIMD")) {
999 if (pa_cpu_init_x86(&(c
->cpu_info
.flags
.x86
)))
1000 c
->cpu_info
.cpu_type
= PA_CPU_X86
;
1001 if (pa_cpu_init_arm(&(c
->cpu_info
.flags
.arm
)))
1002 c
->cpu_info
.cpu_type
= PA_CPU_ARM
;
1003 pa_cpu_init_orc(c
->cpu_info
);
1006 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop
)) == 0);
1007 pa_signal_new(SIGINT
, signal_callback
, c
);
1008 pa_signal_new(SIGTERM
, signal_callback
, c
);
1010 pa_signal_new(SIGUSR1
, signal_callback
, c
);
1013 pa_signal_new(SIGUSR2
, signal_callback
, c
);
1016 pa_signal_new(SIGHUP
, signal_callback
, c
);
1020 win32_timer
= pa_mainloop_get_api(mainloop
)->time_new(pa_mainloop_get_api(mainloop
), pa_gettimeofday(&win32_tv
), message_cb
, NULL
);
1023 if (!conf
->no_cpu_limit
)
1024 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop
)) == 0);
1026 buf
= pa_strbuf_new();
1031 if (conf
->load_default_script_file
) {
1034 if ((f
= pa_daemon_conf_open_default_script_file(conf
))) {
1035 r
= pa_cli_command_execute_file_stream(c
, f
, buf
, &conf
->fail
);
1041 r
= pa_cli_command_execute(c
, conf
->script_commands
, buf
, &conf
->fail
);
1043 pa_log_error("%s", s
= pa_strbuf_tostring_free(buf
));
1046 if (r
< 0 && conf
->fail
) {
1047 pa_log(_("Failed to initialize daemon."));
1051 if (!c
->modules
|| pa_idxset_size(c
->modules
) == 0) {
1052 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1057 /* When we just provide the D-Bus server lookup service, we don't want
1058 * any modules to be loaded. We haven't loaded any so far, so one might
1059 * think there's no way to contact the server, but receiving certain
1060 * signals could still cause modules to load. */
1061 conf
->disallow_module_loading
= TRUE
;
1065 /* We completed the initial module loading, so let's disable it
1066 * from now on, if requested */
1067 c
->disallow_module_loading
= !!conf
->disallow_module_loading
;
1070 if (!conf
->system_instance
) {
1071 if (!(server_lookup
= pa_dbusobj_server_lookup_new(c
)))
1073 if (!(lookup_service_bus
= register_dbus_name(c
, DBUS_BUS_SESSION
, "org.PulseAudio1")))
1077 if (start_server
&& !(server_bus
= register_dbus_name(c
, conf
->system_instance
? DBUS_BUS_SYSTEM
: DBUS_BUS_SESSION
, "org.pulseaudio.Server")))
1082 if (daemon_pipe2
[1] >= 0) {
1084 pa_loop_write(daemon_pipe2
[1], &ok
, sizeof(ok
), NULL
);
1085 pa_close(daemon_pipe2
[1]);
1086 daemon_pipe2
[1] = -1;
1090 pa_log_info(_("Daemon startup complete."));
1093 if (pa_mainloop_run(mainloop
, &retval
) < 0)
1096 pa_log_info(_("Daemon shutdown initiated."));
1101 pa_dbus_connection_unref(server_bus
);
1102 if (lookup_service_bus
)
1103 pa_dbus_connection_unref(lookup_service_bus
);
1105 pa_dbusobj_server_lookup_free(server_lookup
);
1108 if (autospawn_fd
>= 0) {
1109 if (autospawn_locked
)
1110 pa_autospawn_lock_release();
1112 pa_autospawn_lock_done(FALSE
);
1116 if (mainloop
&& win32_timer
)
1117 pa_mainloop_get_api(mainloop
)->time_free(win32_timer
);
1122 pa_log_info(_("Daemon terminated."));
1125 if (!conf
->no_cpu_limit
)
1126 pa_cpu_limit_done();
1131 if (daemon_pipe2
[1] >= 0)
1132 pa_loop_write(daemon_pipe2
[1], &retval
, sizeof(retval
), NULL
);
1134 pa_close_pipe(daemon_pipe2
);
1138 pa_mainloop_free(mainloop
);
1141 pa_daemon_conf_free(conf
);
1144 pa_pid_file_remove();
1146 /* This has no real purpose except making things valgrind-clean */
1147 pa_unset_env_recorded();