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
38 #include <sys/types.h>
41 #ifdef HAVE_SYS_MMAN_H
58 #include <dbus/dbus.h>
61 #include <pulse/client-conf.h>
63 #include <pulse/client-conf-x11.h>
65 #include <pulse/mainloop.h>
66 #include <pulse/mainloop-signal.h>
67 #include <pulse/timeval.h>
68 #include <pulse/xmalloc.h>
70 #include <pulsecore/i18n.h>
71 #include <pulsecore/lock-autospawn.h>
72 #include <pulsecore/socket.h>
73 #include <pulsecore/core-error.h>
74 #include <pulsecore/core-rtclock.h>
75 #include <pulsecore/core-scache.h>
76 #include <pulsecore/core.h>
77 #include <pulsecore/module.h>
78 #include <pulsecore/cli-command.h>
79 #include <pulsecore/log.h>
80 #include <pulsecore/core-util.h>
81 #include <pulsecore/sioman.h>
82 #include <pulsecore/cli-text.h>
83 #include <pulsecore/pid.h>
84 #include <pulsecore/random.h>
85 #include <pulsecore/macro.h>
86 #include <pulsecore/shm.h>
87 #include <pulsecore/memtrap.h>
88 #include <pulsecore/strlist.h>
90 #include <pulsecore/dbus-shared.h>
92 #include <pulsecore/cpu-arm.h>
93 #include <pulsecore/cpu-x86.h>
94 #include <pulsecore/cpu-orc.h>
98 #include "daemon-conf.h"
99 #include "dumpmodules.h"
101 #include "ltdl-bind-now.h"
102 #include "server-lookup.h"
105 /* Only one instance of these variables */
106 int allow_severity
= LOG_INFO
;
107 int deny_severity
= LOG_WARNING
;
110 #ifdef HAVE_OSS_WRAPPER
111 /* padsp looks for this symbol in the running process and disables
112 * itself if it finds it and it is set to 7 (which is actually a bit
113 * mask). For details see padsp. */
114 int __padsp_disabled__
= 7;
119 static void message_cb(pa_mainloop_api
*a
, pa_time_event
*e
, const struct timeval
*tv
, void *userdata
) {
121 struct timeval tvnext
;
123 while (PeekMessage(&msg
, NULL
, 0, 0, PM_REMOVE
)) {
124 if (msg
.message
== WM_QUIT
)
127 TranslateMessage(&msg
);
128 DispatchMessage(&msg
);
132 pa_timeval_add(pa_gettimeofday(&tvnext
), 100000);
133 a
->time_restart(e
, &tvnext
);
138 static void signal_callback(pa_mainloop_api
*m
, pa_signal_event
*e
, int sig
, void *userdata
) {
139 pa_log_info(_("Got signal %s."), pa_sig2str(sig
));
144 pa_module_load(userdata
, "module-cli", NULL
);
150 pa_module_load(userdata
, "module-cli-protocol-unix", NULL
);
156 char *c
= pa_full_status_string(userdata
);
157 pa_log_notice("%s", c
);
166 pa_log_info(_("Exiting."));
172 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
174 static int change_user(void) {
179 /* This function is called only in system-wide mode. It creates a
180 * runtime dir in /var/run/ with proper UID/GID and drops privs
183 if (!(pw
= getpwnam(PA_SYSTEM_USER
))) {
184 pa_log(_("Failed to find user '%s'."), PA_SYSTEM_USER
);
188 if (!(gr
= getgrnam(PA_SYSTEM_GROUP
))) {
189 pa_log(_("Failed to find group '%s'."), PA_SYSTEM_GROUP
);
193 pa_log_info(_("Found user '%s' (UID %lu) and group '%s' (GID %lu)."),
194 PA_SYSTEM_USER
, (unsigned long) pw
->pw_uid
,
195 PA_SYSTEM_GROUP
, (unsigned long) gr
->gr_gid
);
197 if (pw
->pw_gid
!= gr
->gr_gid
) {
198 pa_log(_("GID of user '%s' and of group '%s' don't match."), PA_SYSTEM_USER
, PA_SYSTEM_GROUP
);
202 if (!pa_streq(pw
->pw_dir
, PA_SYSTEM_RUNTIME_PATH
))
203 pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER
, PA_SYSTEM_RUNTIME_PATH
);
205 if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH
, 0755, pw
->pw_uid
, gr
->gr_gid
, TRUE
) < 0) {
206 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH
, pa_cstrerror(errno
));
210 if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH
, 0700, pw
->pw_uid
, gr
->gr_gid
, TRUE
) < 0) {
211 pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH
, pa_cstrerror(errno
));
215 /* We don't create the config dir here, because we don't need to write to it */
217 if (initgroups(PA_SYSTEM_USER
, gr
->gr_gid
) != 0) {
218 pa_log(_("Failed to change group list: %s"), pa_cstrerror(errno
));
222 #if defined(HAVE_SETRESGID)
223 r
= setresgid(gr
->gr_gid
, gr
->gr_gid
, gr
->gr_gid
);
224 #elif defined(HAVE_SETEGID)
225 if ((r
= setgid(gr
->gr_gid
)) >= 0)
226 r
= setegid(gr
->gr_gid
);
227 #elif defined(HAVE_SETREGID)
228 r
= setregid(gr
->gr_gid
, gr
->gr_gid
);
230 #error "No API to drop privileges"
234 pa_log(_("Failed to change GID: %s"), pa_cstrerror(errno
));
238 #if defined(HAVE_SETRESUID)
239 r
= setresuid(pw
->pw_uid
, pw
->pw_uid
, pw
->pw_uid
);
240 #elif defined(HAVE_SETEUID)
241 if ((r
= setuid(pw
->pw_uid
)) >= 0)
242 r
= seteuid(pw
->pw_uid
);
243 #elif defined(HAVE_SETREUID)
244 r
= setreuid(pw
->pw_uid
, pw
->pw_uid
);
246 #error "No API to drop privileges"
250 pa_log(_("Failed to change UID: %s"), pa_cstrerror(errno
));
256 pa_set_env("USER", PA_SYSTEM_USER
);
257 pa_set_env("USERNAME", PA_SYSTEM_USER
);
258 pa_set_env("LOGNAME", PA_SYSTEM_USER
);
259 pa_set_env("HOME", PA_SYSTEM_RUNTIME_PATH
);
261 /* Relevant for pa_runtime_path() */
262 if (!getenv("PULSE_RUNTIME_PATH"))
263 pa_set_env("PULSE_RUNTIME_PATH", PA_SYSTEM_RUNTIME_PATH
);
265 if (!getenv("PULSE_CONFIG_PATH"))
266 pa_set_env("PULSE_CONFIG_PATH", PA_SYSTEM_CONFIG_PATH
);
268 if (!getenv("PULSE_STATE_PATH"))
269 pa_set_env("PULSE_STATE_PATH", PA_SYSTEM_STATE_PATH
);
271 pa_log_info(_("Successfully changed user to \"" PA_SYSTEM_USER
"\"."));
276 #else /* HAVE_PWD_H && HAVE_GRP_H */
278 static int change_user(void) {
279 pa_log(_("System wide mode unsupported on this platform."));
283 #endif /* HAVE_PWD_H && HAVE_GRP_H */
285 #ifdef HAVE_SYS_RESOURCE_H
287 static int set_one_rlimit(const pa_rlimit
*r
, int resource
, const char *name
) {
294 rl
.rlim_cur
= rl
.rlim_max
= r
->value
;
296 if (setrlimit(resource
, &rl
) < 0) {
297 pa_log_info(_("setrlimit(%s, (%u, %u)) failed: %s"), name
, (unsigned) r
->value
, (unsigned) r
->value
, pa_cstrerror(errno
));
304 static void set_all_rlimits(const pa_daemon_conf
*conf
) {
305 set_one_rlimit(&conf
->rlimit_fsize
, RLIMIT_FSIZE
, "RLIMIT_FSIZE");
306 set_one_rlimit(&conf
->rlimit_data
, RLIMIT_DATA
, "RLIMIT_DATA");
307 set_one_rlimit(&conf
->rlimit_stack
, RLIMIT_STACK
, "RLIMIT_STACK");
308 set_one_rlimit(&conf
->rlimit_core
, RLIMIT_CORE
, "RLIMIT_CORE");
310 set_one_rlimit(&conf
->rlimit_rss
, RLIMIT_RSS
, "RLIMIT_RSS");
313 set_one_rlimit(&conf
->rlimit_nproc
, RLIMIT_NPROC
, "RLIMIT_NPROC");
316 set_one_rlimit(&conf
->rlimit_nofile
, RLIMIT_NOFILE
, "RLIMIT_NOFILE");
318 #ifdef RLIMIT_MEMLOCK
319 set_one_rlimit(&conf
->rlimit_memlock
, RLIMIT_MEMLOCK
, "RLIMIT_MEMLOCK");
322 set_one_rlimit(&conf
->rlimit_as
, RLIMIT_AS
, "RLIMIT_AS");
325 set_one_rlimit(&conf
->rlimit_locks
, RLIMIT_LOCKS
, "RLIMIT_LOCKS");
327 #ifdef RLIMIT_SIGPENDING
328 set_one_rlimit(&conf
->rlimit_sigpending
, RLIMIT_SIGPENDING
, "RLIMIT_SIGPENDING");
330 #ifdef RLIMIT_MSGQUEUE
331 set_one_rlimit(&conf
->rlimit_msgqueue
, RLIMIT_MSGQUEUE
, "RLIMIT_MSGQUEUE");
334 set_one_rlimit(&conf
->rlimit_nice
, RLIMIT_NICE
, "RLIMIT_NICE");
337 set_one_rlimit(&conf
->rlimit_rtprio
, RLIMIT_RTPRIO
, "RLIMIT_RTPRIO");
340 set_one_rlimit(&conf
->rlimit_rttime
, RLIMIT_RTTIME
, "RLIMIT_RTTIME");
345 static char *check_configured_address(void) {
346 char *default_server
= NULL
;
347 pa_client_conf
*c
= pa_client_conf_new();
349 pa_client_conf_load(c
, NULL
);
351 pa_client_conf_from_x11(c
, NULL
);
353 pa_client_conf_env(c
);
355 if (c
->default_server
&& *c
->default_server
)
356 default_server
= pa_xstrdup(c
->default_server
);
358 pa_client_conf_free(c
);
360 return default_server
;
364 static pa_dbus_connection
*register_dbus_name(pa_core
*c
, DBusBusType bus
, const char* name
) {
366 pa_dbus_connection
*conn
;
368 dbus_error_init(&error
);
370 if (!(conn
= pa_dbus_bus_get(c
, bus
, &error
)) || dbus_error_is_set(&error
)) {
371 pa_log_warn("Unable to contact D-Bus: %s: %s", error
.name
, error
.message
);
375 if (dbus_bus_request_name(pa_dbus_connection_get(conn
), name
, DBUS_NAME_FLAG_DO_NOT_QUEUE
, &error
) == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER
) {
376 pa_log_debug("Got %s!", name
);
380 if (dbus_error_is_set(&error
))
381 pa_log_error("Failed to acquire %s: %s: %s", name
, error
.name
, error
.message
);
383 pa_log_error("D-Bus name %s already taken.", name
);
385 /* PA cannot be started twice by the same user and hence we can
386 * ignore mostly the case that a name is already taken. */
390 pa_dbus_connection_unref(conn
);
392 dbus_error_free(&error
);
397 int main(int argc
, char *argv
[]) {
399 pa_strbuf
*buf
= NULL
;
400 pa_daemon_conf
*conf
= NULL
;
401 pa_mainloop
*mainloop
= NULL
;
403 char *configured_address
;
404 int r
= 0, retval
= 1, d
= 0;
405 pa_bool_t valid_pid_file
= FALSE
;
406 pa_bool_t ltdl_init
= FALSE
;
410 int daemon_pipe
[2] = { -1, -1 };
411 int daemon_pipe2
[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 /* There is an server address in our config, but where did it come from?
675 * By default a standard X11 login will load module-x11-publish which will
676 * inject PULSE_SERVER X11 property. If the PA daemon crashes, we will end
677 * up hitting this code path. So we have to check to see if our configured_address
678 * is the same as the value that would go into this property so that we can
679 * recover (i.e. autospawn) from a crash.
682 pa_bool_t start_anyway
= FALSE
;
684 if ((ufn
= pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET
))) {
687 if ((id
= pa_machine_id())) {
688 pa_strlist
*server_list
;
689 char formatted_ufn
[256];
691 pa_snprintf(formatted_ufn
, sizeof(formatted_ufn
), "{%s}unix:%s", id
, ufn
);
694 if ((server_list
= pa_strlist_parse(configured_address
))) {
697 /* We only need to check the first server */
698 server_list
= pa_strlist_pop(server_list
, &u
);
699 pa_strlist_free(server_list
);
701 start_anyway
= (u
&& pa_streq(formatted_ufn
, u
));
709 pa_log_notice(_("User-configured server at %s, refusing to start/autospawn."), configured_address
);
710 pa_xfree(configured_address
);
715 pa_log_notice(_("User-configured server at %s, which appears to be local. Probing deeper."), configured_address
);
716 pa_xfree(configured_address
);
719 if (conf
->system_instance
&& !conf
->disallow_exit
)
720 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
722 if (conf
->system_instance
&& !conf
->disallow_module_loading
)
723 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
725 if (conf
->system_instance
&& !conf
->disable_shm
) {
726 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
727 conf
->disable_shm
= TRUE
;
730 if (conf
->system_instance
&& conf
->exit_idle_time
>= 0) {
731 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
732 conf
->exit_idle_time
= -1;
735 if (conf
->cmd
== PA_CMD_START
) {
736 /* If we shall start PA only when it is not running yet, we
737 * first take the autospawn lock to make things
740 if ((autospawn_fd
= pa_autospawn_lock_init()) < 0) {
741 pa_log("Failed to initialize autospawn lock");
745 if ((pa_autospawn_lock_acquire(TRUE
) < 0)) {
746 pa_log("Failed to acquire autospawn lock");
750 autospawn_locked
= TRUE
;
753 if (conf
->daemonize
) {
758 if (pa_stdio_acquire() < 0) {
759 pa_log(_("Failed to acquire stdio."));
764 if (pipe(daemon_pipe
) < 0) {
765 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno
));
769 if ((child
= fork()) < 0) {
770 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
771 pa_close_pipe(daemon_pipe
);
779 pa_assert_se(pa_close(daemon_pipe
[1]) == 0);
782 if ((n
= pa_loop_read(daemon_pipe
[0], &retval
, sizeof(retval
), NULL
)) != sizeof(retval
)) {
785 pa_log(_("read() failed: %s"), pa_cstrerror(errno
));
791 pa_log(_("Daemon startup failed."));
793 pa_log_info(_("Daemon startup successful."));
798 if (autospawn_fd
>= 0) {
799 /* The lock file is unlocked from the parent, so we need
800 * to close it in the child */
802 pa_autospawn_lock_release();
803 pa_autospawn_lock_done(TRUE
);
805 autospawn_locked
= FALSE
;
809 pa_assert_se(pa_close(daemon_pipe
[0]) == 0);
813 if (conf
->auto_log_target
)
814 pa_log_set_target(PA_LOG_SYSLOG
);
818 pa_log(_("setsid() failed: %s"), pa_cstrerror(errno
));
824 /* We now are a session and process group leader. Let's fork
825 * again and let the father die, so that we'll become a
826 * process that can never acquire a TTY again, in a session and
827 * process group without leader */
829 if (pipe(daemon_pipe2
) < 0) {
830 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno
));
834 if ((child
= fork()) < 0) {
835 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
836 pa_close_pipe(daemon_pipe2
);
844 pa_assert_se(pa_close(daemon_pipe2
[1]) == 0);
845 daemon_pipe2
[1] = -1;
847 if ((n
= pa_loop_read(daemon_pipe2
[0], &retval
, sizeof(retval
), NULL
)) != sizeof(retval
)) {
850 pa_log(_("read() failed: %s"), pa_cstrerror(errno
));
855 /* We now have to take care of signalling the first fork with
856 * the return value we've received from this fork... */
857 pa_assert(daemon_pipe
[1] >= 0);
859 pa_loop_write(daemon_pipe
[1], &retval
, sizeof(retval
), NULL
);
860 pa_close(daemon_pipe
[1]);
866 pa_assert_se(pa_close(daemon_pipe2
[0]) == 0);
867 daemon_pipe2
[0] = -1;
869 /* We no longer need the (first) daemon_pipe as it's handled in our child above */
870 pa_close_pipe(daemon_pipe
);
874 signal(SIGTTOU
, SIG_IGN
);
877 signal(SIGTTIN
, SIG_IGN
);
880 signal(SIGTSTP
, SIG_IGN
);
886 pa_set_env_and_record("PULSE_INTERNAL", "1");
887 pa_assert_se(chdir("/") == 0);
890 #ifdef HAVE_SYS_RESOURCE_H
891 set_all_rlimits(conf
);
893 pa_rtclock_hrtimer_enable();
895 pa_raise_priority(conf
->nice_level
);
897 if (conf
->system_instance
)
898 if (change_user() < 0)
901 pa_set_env_and_record("PULSE_SYSTEM", conf
->system_instance
? "1" : "0");
903 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION
);
904 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST
);
905 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS
);
907 s
= pa_uname_string();
908 pa_log_debug(_("Running on host: %s"), s
);
911 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
913 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE
);
915 #ifdef HAVE_VALGRIND_MEMCHECK_H
916 pa_log_debug(_("Compiled with Valgrind support: yes"));
918 pa_log_debug(_("Compiled with Valgrind support: no"));
921 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
923 pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
926 pa_log_debug(_("Optimized build: yes"));
928 pa_log_debug(_("Optimized build: no"));
932 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
933 #elif defined(FASTPATH)
934 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
936 pa_log_debug(_("All asserts enabled."));
939 if (!(s
= pa_machine_id())) {
940 pa_log(_("Failed to get machine ID"));
943 pa_log_info(_("Machine ID is %s."), s
);
946 if ((s
= pa_session_id())) {
947 pa_log_info(_("Session ID is %s."), s
);
951 if (!(s
= pa_get_runtime_dir()))
953 pa_log_info(_("Using runtime directory %s."), s
);
956 if (!(s
= pa_get_state_dir()))
958 pa_log_info(_("Using state directory %s."), s
);
961 pa_log_info(_("Using modules directory %s."), conf
->dl_search_path
);
963 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
965 if (pa_in_system_mode())
966 pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
967 "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
968 "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
970 if (conf
->use_pid_file
) {
973 if ((z
= pa_pid_file_create("pulseaudio")) != 0) {
975 if (conf
->cmd
== PA_CMD_START
&& z
> 0) {
976 /* If we are already running and with are run in
977 * --start mode, then let's return this as success. */
983 pa_log(_("pa_pid_file_create() failed."));
987 valid_pid_file
= TRUE
;
990 pa_disable_sigpipe();
992 if (pa_rtclock_hrtimer())
993 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
995 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
997 if (conf
->lock_memory
) {
998 #ifdef HAVE_SYS_MMAN_H
999 if (mlockall(MCL_FUTURE
) < 0)
1000 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno
));
1002 pa_log_info("Successfully locked process into memory.");
1004 pa_log_warn("Memory locking requested but not supported on platform.");
1008 pa_memtrap_install();
1010 pa_assert_se(mainloop
= pa_mainloop_new());
1012 if (!(c
= pa_core_new(pa_mainloop_get_api(mainloop
), !conf
->disable_shm
, conf
->shm_size
))) {
1013 pa_log(_("pa_core_new() failed."));
1017 c
->default_sample_spec
= conf
->default_sample_spec
;
1018 c
->alternate_sample_rate
= conf
->alternate_sample_rate
;
1019 c
->default_channel_map
= conf
->default_channel_map
;
1020 c
->default_n_fragments
= conf
->default_n_fragments
;
1021 c
->default_fragment_size_msec
= conf
->default_fragment_size_msec
;
1022 c
->deferred_volume_safety_margin_usec
= conf
->deferred_volume_safety_margin_usec
;
1023 c
->deferred_volume_extra_delay_usec
= conf
->deferred_volume_extra_delay_usec
;
1024 c
->exit_idle_time
= conf
->exit_idle_time
;
1025 c
->scache_idle_time
= conf
->scache_idle_time
;
1026 c
->resample_method
= conf
->resample_method
;
1027 c
->realtime_priority
= conf
->realtime_priority
;
1028 c
->realtime_scheduling
= !!conf
->realtime_scheduling
;
1029 c
->disable_remixing
= !!conf
->disable_remixing
;
1030 c
->disable_lfe_remixing
= !!conf
->disable_lfe_remixing
;
1031 c
->deferred_volume
= !!conf
->deferred_volume
;
1032 c
->running_as_daemon
= !!conf
->daemonize
;
1033 c
->disallow_exit
= conf
->disallow_exit
;
1034 c
->flat_volumes
= conf
->flat_volumes
;
1036 c
->server_type
= conf
->local_server_type
;
1039 c
->cpu_info
.cpu_type
= PA_CPU_UNDEFINED
;
1040 if (!getenv("PULSE_NO_SIMD")) {
1041 if (pa_cpu_init_x86(&(c
->cpu_info
.flags
.x86
)))
1042 c
->cpu_info
.cpu_type
= PA_CPU_X86
;
1043 if (pa_cpu_init_arm(&(c
->cpu_info
.flags
.arm
)))
1044 c
->cpu_info
.cpu_type
= PA_CPU_ARM
;
1045 pa_cpu_init_orc(c
->cpu_info
);
1048 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop
)) == 0);
1049 pa_signal_new(SIGINT
, signal_callback
, c
);
1050 pa_signal_new(SIGTERM
, signal_callback
, c
);
1052 pa_signal_new(SIGUSR1
, signal_callback
, c
);
1055 pa_signal_new(SIGUSR2
, signal_callback
, c
);
1058 pa_signal_new(SIGHUP
, signal_callback
, c
);
1062 win32_timer
= pa_mainloop_get_api(mainloop
)->time_new(pa_mainloop_get_api(mainloop
), pa_gettimeofday(&win32_tv
), message_cb
, NULL
);
1065 if (!conf
->no_cpu_limit
)
1066 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop
)) == 0);
1068 buf
= pa_strbuf_new();
1071 pa_assert_se(dbus_threads_init_default());
1075 if (conf
->load_default_script_file
) {
1078 if ((f
= pa_daemon_conf_open_default_script_file(conf
))) {
1079 r
= pa_cli_command_execute_file_stream(c
, f
, buf
, &conf
->fail
);
1085 r
= pa_cli_command_execute(c
, conf
->script_commands
, buf
, &conf
->fail
);
1087 pa_log_error("%s", s
= pa_strbuf_tostring_free(buf
));
1090 if (r
< 0 && conf
->fail
) {
1091 pa_log(_("Failed to initialize daemon."));
1095 if (!c
->modules
|| pa_idxset_size(c
->modules
) == 0) {
1096 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1101 /* When we just provide the D-Bus server lookup service, we don't want
1102 * any modules to be loaded. We haven't loaded any so far, so one might
1103 * think there's no way to contact the server, but receiving certain
1104 * signals could still cause modules to load. */
1105 conf
->disallow_module_loading
= TRUE
;
1109 /* We completed the initial module loading, so let's disable it
1110 * from now on, if requested */
1111 c
->disallow_module_loading
= !!conf
->disallow_module_loading
;
1114 if (!conf
->system_instance
) {
1115 if ((server_lookup
= pa_dbusobj_server_lookup_new(c
))) {
1116 if (!(lookup_service_bus
= register_dbus_name(c
, DBUS_BUS_SESSION
, "org.PulseAudio1")))
1122 server_bus
= register_dbus_name(c
, conf
->system_instance
? DBUS_BUS_SYSTEM
: DBUS_BUS_SESSION
, "org.pulseaudio.Server");
1126 if (daemon_pipe2
[1] >= 0) {
1128 pa_loop_write(daemon_pipe2
[1], &ok
, sizeof(ok
), NULL
);
1129 pa_close(daemon_pipe2
[1]);
1130 daemon_pipe2
[1] = -1;
1134 pa_log_info(_("Daemon startup complete."));
1137 if (pa_mainloop_run(mainloop
, &retval
) < 0)
1140 pa_log_info(_("Daemon shutdown initiated."));
1145 pa_dbus_connection_unref(server_bus
);
1146 if (lookup_service_bus
)
1147 pa_dbus_connection_unref(lookup_service_bus
);
1149 pa_dbusobj_server_lookup_free(server_lookup
);
1152 if (autospawn_fd
>= 0) {
1153 if (autospawn_locked
)
1154 pa_autospawn_lock_release();
1156 pa_autospawn_lock_done(FALSE
);
1160 if (mainloop
&& win32_timer
)
1161 pa_mainloop_get_api(mainloop
)->time_free(win32_timer
);
1165 /* Ensure all the modules/samples are unloaded when the core is still ref'ed,
1166 * as unlink callback hooks in modules may need the core to be ref'ed */
1167 pa_module_unload_all(c
);
1168 pa_scache_free_all(c
);
1171 pa_log_info(_("Daemon terminated."));
1174 if (!conf
->no_cpu_limit
)
1175 pa_cpu_limit_done();
1180 /* If we have daemon_pipe[1] still open, this means we've failed after
1181 * the first fork, but before the second. Therefore just write to it. */
1182 if (daemon_pipe
[1] >= 0)
1183 pa_loop_write(daemon_pipe
[1], &retval
, sizeof(retval
), NULL
);
1184 else if (daemon_pipe2
[1] >= 0)
1185 pa_loop_write(daemon_pipe2
[1], &retval
, sizeof(retval
), NULL
);
1187 pa_close_pipe(daemon_pipe2
);
1188 pa_close_pipe(daemon_pipe
);
1192 pa_mainloop_free(mainloop
);
1195 pa_daemon_conf_free(conf
);
1198 pa_pid_file_remove();
1200 /* This has no real purpose except making things valgrind-clean */
1201 pa_unset_env_recorded();