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 bool valid_pid_file
= false;
406 bool 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 bool 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. */
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 if (conf
->log_target
)
503 pa_log_set_target(conf
->log_target
);
505 pa_log_target target
= { .type
= PA_LOG_STDERR
, .file
= NULL
};
506 pa_log_set_target(&target
);
509 pa_log_set_level(conf
->log_level
);
511 pa_log_set_flags(PA_LOG_PRINT_META
, PA_LOG_SET
);
513 pa_log_set_flags(PA_LOG_PRINT_TIME
, PA_LOG_SET
);
514 pa_log_set_show_backtrace(conf
->log_backtrace
);
517 /* conf->system_instance and conf->local_server_type control almost the
518 * same thing; make them agree about what is requested. */
519 switch (conf
->local_server_type
) {
520 case PA_SERVER_TYPE_UNSET
:
521 conf
->local_server_type
= conf
->system_instance
? PA_SERVER_TYPE_SYSTEM
: PA_SERVER_TYPE_USER
;
523 case PA_SERVER_TYPE_USER
:
524 case PA_SERVER_TYPE_NONE
:
525 conf
->system_instance
= false;
527 case PA_SERVER_TYPE_SYSTEM
:
528 conf
->system_instance
= true;
531 pa_assert_not_reached();
534 start_server
= conf
->local_server_type
== PA_SERVER_TYPE_USER
|| (getuid() == 0 && conf
->local_server_type
== PA_SERVER_TYPE_SYSTEM
);
536 if (!start_server
&& conf
->local_server_type
== PA_SERVER_TYPE_SYSTEM
) {
537 pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
538 conf
->system_instance
= false;
542 LTDL_SET_PRELOADED_SYMBOLS();
546 if (conf
->dl_search_path
)
547 lt_dlsetsearchpath(conf
->dl_search_path
);
552 WSAStartup(MAKEWORD(2, 0), &data
);
559 case PA_CMD_DUMP_MODULES
:
560 pa_dump_modules(conf
, argc
-d
, argv
+d
);
564 case PA_CMD_DUMP_CONF
: {
567 pa_log("Too many arguments.\n");
571 s
= pa_daemon_conf_dump(conf
);
578 case PA_CMD_DUMP_RESAMPLE_METHODS
: {
582 pa_log("Too many arguments.\n");
586 for (i
= 0; i
< PA_RESAMPLER_MAX
; i
++)
587 if (pa_resample_method_supported(i
))
588 printf("%s\n", pa_resample_method_to_string(i
));
595 pa_cmdline_help(argv
[0]);
599 case PA_CMD_VERSION
:
602 pa_log("Too many arguments.\n");
606 printf(PACKAGE_NAME
" "PACKAGE_VERSION
"\n");
614 pa_log("Too many arguments.\n");
618 if (pa_pid_file_check_running(&pid
, "pulseaudio") < 0)
619 pa_log_info(_("Daemon not running"));
621 pa_log_info(_("Daemon running as PID %u"), pid
);
631 pa_log("Too many arguments.\n");
635 if (pa_pid_file_kill(SIGINT
, NULL
, "pulseaudio") < 0)
636 pa_log(_("Failed to kill daemon: %s"), pa_cstrerror(errno
));
642 case PA_CMD_CLEANUP_SHM
:
645 pa_log("Too many arguments.\n");
649 if (pa_shm_cleanup() >= 0)
655 pa_assert(conf
->cmd
== PA_CMD_DAEMON
|| conf
->cmd
== PA_CMD_START
);
659 pa_log("Too many arguments.\n");
664 if (getuid() == 0 && !conf
->system_instance
)
665 pa_log_warn(_("This program is not intended to be run as root (unless --system is specified)."));
666 #ifndef HAVE_DBUS /* A similar, only a notice worthy check was done earlier, if D-Bus is enabled. */
667 else if (getuid() != 0 && conf
->system_instance
) {
668 pa_log(_("Root privileges required."));
672 #endif /* HAVE_GETUID */
674 if (conf
->cmd
== PA_CMD_START
&& conf
->system_instance
) {
675 pa_log(_("--start not supported for system instances."));
679 if (conf
->cmd
== PA_CMD_START
&& (configured_address
= check_configured_address())) {
680 /* There is an server address in our config, but where did it come from?
681 * By default a standard X11 login will load module-x11-publish which will
682 * inject PULSE_SERVER X11 property. If the PA daemon crashes, we will end
683 * up hitting this code path. So we have to check to see if our configured_address
684 * is the same as the value that would go into this property so that we can
685 * recover (i.e. autospawn) from a crash.
688 bool start_anyway
= false;
690 if ((ufn
= pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET
))) {
693 if ((id
= pa_machine_id())) {
694 pa_strlist
*server_list
;
695 char formatted_ufn
[256];
697 pa_snprintf(formatted_ufn
, sizeof(formatted_ufn
), "{%s}unix:%s", id
, ufn
);
700 if ((server_list
= pa_strlist_parse(configured_address
))) {
703 /* We only need to check the first server */
704 server_list
= pa_strlist_pop(server_list
, &u
);
705 pa_strlist_free(server_list
);
707 start_anyway
= (u
&& pa_streq(formatted_ufn
, u
));
715 pa_log_notice(_("User-configured server at %s, refusing to start/autospawn."), configured_address
);
716 pa_xfree(configured_address
);
721 pa_log_notice(_("User-configured server at %s, which appears to be local. Probing deeper."), configured_address
);
722 pa_xfree(configured_address
);
725 if (conf
->system_instance
&& !conf
->disallow_exit
)
726 pa_log_warn(_("Running in system mode, but --disallow-exit not set!"));
728 if (conf
->system_instance
&& !conf
->disallow_module_loading
)
729 pa_log_warn(_("Running in system mode, but --disallow-module-loading not set!"));
731 if (conf
->system_instance
&& !conf
->disable_shm
) {
732 pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
733 conf
->disable_shm
= true;
736 if (conf
->system_instance
&& conf
->exit_idle_time
>= 0) {
737 pa_log_notice(_("Running in system mode, forcibly disabling exit idle time!"));
738 conf
->exit_idle_time
= -1;
741 if (conf
->cmd
== PA_CMD_START
) {
742 /* If we shall start PA only when it is not running yet, we
743 * first take the autospawn lock to make things
746 if ((autospawn_fd
= pa_autospawn_lock_init()) < 0) {
747 pa_log("Failed to initialize autospawn lock");
751 if ((pa_autospawn_lock_acquire(true) < 0)) {
752 pa_log("Failed to acquire autospawn lock");
756 autospawn_locked
= true;
759 if (conf
->daemonize
) {
764 if (pa_stdio_acquire() < 0) {
765 pa_log(_("Failed to acquire stdio."));
770 if (pipe(daemon_pipe
) < 0) {
771 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno
));
775 if ((child
= fork()) < 0) {
776 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
777 pa_close_pipe(daemon_pipe
);
785 pa_assert_se(pa_close(daemon_pipe
[1]) == 0);
788 if ((n
= pa_loop_read(daemon_pipe
[0], &retval
, sizeof(retval
), NULL
)) != sizeof(retval
)) {
791 pa_log(_("read() failed: %s"), pa_cstrerror(errno
));
797 pa_log(_("Daemon startup failed."));
799 pa_log_info(_("Daemon startup successful."));
804 if (autospawn_fd
>= 0) {
805 /* The lock file is unlocked from the parent, so we need
806 * to close it in the child */
808 pa_autospawn_lock_release();
809 pa_autospawn_lock_done(true);
811 autospawn_locked
= false;
815 pa_assert_se(pa_close(daemon_pipe
[0]) == 0);
819 if (!conf
->log_target
) {
821 pa_log_target target
= { .type
= PA_LOG_JOURNAL
, .file
= NULL
};
823 pa_log_target target
= { .type
= PA_LOG_SYSLOG
, .file
= NULL
};
825 pa_log_set_target(&target
);
830 pa_log(_("setsid() failed: %s"), pa_cstrerror(errno
));
836 /* We now are a session and process group leader. Let's fork
837 * again and let the father die, so that we'll become a
838 * process that can never acquire a TTY again, in a session and
839 * process group without leader */
841 if (pipe(daemon_pipe2
) < 0) {
842 pa_log(_("pipe() failed: %s"), pa_cstrerror(errno
));
846 if ((child
= fork()) < 0) {
847 pa_log(_("fork() failed: %s"), pa_cstrerror(errno
));
848 pa_close_pipe(daemon_pipe2
);
856 pa_assert_se(pa_close(daemon_pipe2
[1]) == 0);
857 daemon_pipe2
[1] = -1;
859 if ((n
= pa_loop_read(daemon_pipe2
[0], &retval
, sizeof(retval
), NULL
)) != sizeof(retval
)) {
862 pa_log(_("read() failed: %s"), pa_cstrerror(errno
));
867 /* We now have to take care of signalling the first fork with
868 * the return value we've received from this fork... */
869 pa_assert(daemon_pipe
[1] >= 0);
871 pa_loop_write(daemon_pipe
[1], &retval
, sizeof(retval
), NULL
);
872 pa_close(daemon_pipe
[1]);
878 pa_assert_se(pa_close(daemon_pipe2
[0]) == 0);
879 daemon_pipe2
[0] = -1;
881 /* We no longer need the (first) daemon_pipe as it's handled in our child above */
882 pa_close_pipe(daemon_pipe
);
886 signal(SIGTTOU
, SIG_IGN
);
889 signal(SIGTTIN
, SIG_IGN
);
892 signal(SIGTSTP
, SIG_IGN
);
898 pa_set_env_and_record("PULSE_INTERNAL", "1");
899 pa_assert_se(chdir("/") == 0);
902 #ifdef HAVE_SYS_RESOURCE_H
903 set_all_rlimits(conf
);
905 pa_rtclock_hrtimer_enable();
907 if (conf
->high_priority
)
908 pa_raise_priority(conf
->nice_level
);
910 if (conf
->system_instance
)
911 if (change_user() < 0)
914 pa_set_env_and_record("PULSE_SYSTEM", conf
->system_instance
? "1" : "0");
916 pa_log_info(_("This is PulseAudio %s"), PACKAGE_VERSION
);
917 pa_log_debug(_("Compilation host: %s"), CANONICAL_HOST
);
918 pa_log_debug(_("Compilation CFLAGS: %s"), PA_CFLAGS
);
920 s
= pa_uname_string();
921 pa_log_debug(_("Running on host: %s"), s
);
924 pa_log_debug(_("Found %u CPUs."), pa_ncpus());
926 pa_log_info(_("Page size is %lu bytes"), (unsigned long) PA_PAGE_SIZE
);
928 #ifdef HAVE_VALGRIND_MEMCHECK_H
929 pa_log_debug(_("Compiled with Valgrind support: yes"));
931 pa_log_debug(_("Compiled with Valgrind support: no"));
934 pa_log_debug(_("Running in valgrind mode: %s"), pa_yes_no(pa_in_valgrind()));
936 pa_log_debug(_("Running in VM: %s"), pa_yes_no(pa_running_in_vm()));
939 pa_log_debug(_("Optimized build: yes"));
941 pa_log_debug(_("Optimized build: no"));
945 pa_log_debug(_("NDEBUG defined, all asserts disabled."));
946 #elif defined(FASTPATH)
947 pa_log_debug(_("FASTPATH defined, only fast path asserts disabled."));
949 pa_log_debug(_("All asserts enabled."));
952 if (!(s
= pa_machine_id())) {
953 pa_log(_("Failed to get machine ID"));
956 pa_log_info(_("Machine ID is %s."), s
);
959 if ((s
= pa_session_id())) {
960 pa_log_info(_("Session ID is %s."), s
);
964 if (!(s
= pa_get_runtime_dir()))
966 pa_log_info(_("Using runtime directory %s."), s
);
969 if (!(s
= pa_get_state_dir()))
971 pa_log_info(_("Using state directory %s."), s
);
974 pa_log_info(_("Using modules directory %s."), conf
->dl_search_path
);
976 pa_log_info(_("Running in system mode: %s"), pa_yes_no(pa_in_system_mode()));
978 if (pa_in_system_mode())
979 pa_log_warn(_("OK, so you are running PA in system mode. Please note that you most likely shouldn't be doing that.\n"
980 "If you do it nonetheless then it's your own fault if things don't work as expected.\n"
981 "Please read http://pulseaudio.org/wiki/WhatIsWrongWithSystemMode for an explanation why system mode is usually a bad idea."));
983 if (conf
->use_pid_file
) {
986 if ((z
= pa_pid_file_create("pulseaudio")) != 0) {
988 if (conf
->cmd
== PA_CMD_START
&& z
> 0) {
989 /* If we are already running and with are run in
990 * --start mode, then let's return this as success. */
996 pa_log(_("pa_pid_file_create() failed."));
1000 valid_pid_file
= true;
1003 pa_disable_sigpipe();
1005 if (pa_rtclock_hrtimer())
1006 pa_log_info(_("Fresh high-resolution timers available! Bon appetit!"));
1008 pa_log_info(_("Dude, your kernel stinks! The chef's recommendation today is Linux with high-resolution timers enabled!"));
1010 if (conf
->lock_memory
) {
1011 #if defined(HAVE_SYS_MMAN_H) && !defined(__ANDROID__)
1012 if (mlockall(MCL_FUTURE
) < 0)
1013 pa_log_warn("mlockall() failed: %s", pa_cstrerror(errno
));
1015 pa_log_info("Successfully locked process into memory.");
1017 pa_log_warn("Memory locking requested but not supported on platform.");
1021 pa_memtrap_install();
1023 pa_assert_se(mainloop
= pa_mainloop_new());
1025 if (!(c
= pa_core_new(pa_mainloop_get_api(mainloop
), !conf
->disable_shm
, conf
->shm_size
))) {
1026 pa_log(_("pa_core_new() failed."));
1030 c
->default_sample_spec
= conf
->default_sample_spec
;
1031 c
->alternate_sample_rate
= conf
->alternate_sample_rate
;
1032 c
->default_channel_map
= conf
->default_channel_map
;
1033 c
->default_n_fragments
= conf
->default_n_fragments
;
1034 c
->default_fragment_size_msec
= conf
->default_fragment_size_msec
;
1035 c
->deferred_volume_safety_margin_usec
= conf
->deferred_volume_safety_margin_usec
;
1036 c
->deferred_volume_extra_delay_usec
= conf
->deferred_volume_extra_delay_usec
;
1037 c
->exit_idle_time
= conf
->exit_idle_time
;
1038 c
->scache_idle_time
= conf
->scache_idle_time
;
1039 c
->resample_method
= conf
->resample_method
;
1040 c
->realtime_priority
= conf
->realtime_priority
;
1041 c
->realtime_scheduling
= !!conf
->realtime_scheduling
;
1042 c
->disable_remixing
= !!conf
->disable_remixing
;
1043 c
->disable_lfe_remixing
= !!conf
->disable_lfe_remixing
;
1044 c
->deferred_volume
= !!conf
->deferred_volume
;
1045 c
->running_as_daemon
= !!conf
->daemonize
;
1046 c
->disallow_exit
= conf
->disallow_exit
;
1047 c
->flat_volumes
= conf
->flat_volumes
;
1049 c
->server_type
= conf
->local_server_type
;
1052 c
->cpu_info
.cpu_type
= PA_CPU_UNDEFINED
;
1053 if (!getenv("PULSE_NO_SIMD")) {
1054 if (pa_cpu_init_x86(&(c
->cpu_info
.flags
.x86
)))
1055 c
->cpu_info
.cpu_type
= PA_CPU_X86
;
1056 if (pa_cpu_init_arm(&(c
->cpu_info
.flags
.arm
)))
1057 c
->cpu_info
.cpu_type
= PA_CPU_ARM
;
1058 pa_cpu_init_orc(c
->cpu_info
);
1061 pa_assert_se(pa_signal_init(pa_mainloop_get_api(mainloop
)) == 0);
1062 pa_signal_new(SIGINT
, signal_callback
, c
);
1063 pa_signal_new(SIGTERM
, signal_callback
, c
);
1065 pa_signal_new(SIGUSR1
, signal_callback
, c
);
1068 pa_signal_new(SIGUSR2
, signal_callback
, c
);
1071 pa_signal_new(SIGHUP
, signal_callback
, c
);
1075 win32_timer
= pa_mainloop_get_api(mainloop
)->time_new(pa_mainloop_get_api(mainloop
), pa_gettimeofday(&win32_tv
), message_cb
, NULL
);
1078 if (!conf
->no_cpu_limit
)
1079 pa_assert_se(pa_cpu_limit_init(pa_mainloop_get_api(mainloop
)) == 0);
1081 buf
= pa_strbuf_new();
1084 pa_assert_se(dbus_threads_init_default());
1088 if (conf
->load_default_script_file
) {
1091 if ((f
= pa_daemon_conf_open_default_script_file(conf
))) {
1092 r
= pa_cli_command_execute_file_stream(c
, f
, buf
, &conf
->fail
);
1098 r
= pa_cli_command_execute(c
, conf
->script_commands
, buf
, &conf
->fail
);
1100 pa_log_error("%s", s
= pa_strbuf_tostring_free(buf
));
1103 if (r
< 0 && conf
->fail
) {
1104 pa_log(_("Failed to initialize daemon."));
1108 if (!c
->modules
|| pa_idxset_size(c
->modules
) == 0) {
1109 pa_log(_("Daemon startup without any loaded modules, refusing to work."));
1114 /* When we just provide the D-Bus server lookup service, we don't want
1115 * any modules to be loaded. We haven't loaded any so far, so one might
1116 * think there's no way to contact the server, but receiving certain
1117 * signals could still cause modules to load. */
1118 conf
->disallow_module_loading
= true;
1122 /* We completed the initial module loading, so let's disable it
1123 * from now on, if requested */
1124 c
->disallow_module_loading
= !!conf
->disallow_module_loading
;
1127 if (!conf
->system_instance
) {
1128 if ((server_lookup
= pa_dbusobj_server_lookup_new(c
))) {
1129 if (!(lookup_service_bus
= register_dbus_name(c
, DBUS_BUS_SESSION
, "org.PulseAudio1")))
1135 server_bus
= register_dbus_name(c
, conf
->system_instance
? DBUS_BUS_SYSTEM
: DBUS_BUS_SESSION
, "org.pulseaudio.Server");
1139 if (daemon_pipe2
[1] >= 0) {
1141 pa_loop_write(daemon_pipe2
[1], &ok
, sizeof(ok
), NULL
);
1142 pa_close(daemon_pipe2
[1]);
1143 daemon_pipe2
[1] = -1;
1147 pa_log_info(_("Daemon startup complete."));
1150 if (pa_mainloop_run(mainloop
, &retval
) < 0)
1153 pa_log_info(_("Daemon shutdown initiated."));
1158 pa_dbus_connection_unref(server_bus
);
1159 if (lookup_service_bus
)
1160 pa_dbus_connection_unref(lookup_service_bus
);
1162 pa_dbusobj_server_lookup_free(server_lookup
);
1165 if (autospawn_fd
>= 0) {
1166 if (autospawn_locked
)
1167 pa_autospawn_lock_release();
1169 pa_autospawn_lock_done(false);
1173 if (mainloop
&& win32_timer
)
1174 pa_mainloop_get_api(mainloop
)->time_free(win32_timer
);
1178 /* Ensure all the modules/samples are unloaded when the core is still ref'ed,
1179 * as unlink callback hooks in modules may need the core to be ref'ed */
1180 pa_module_unload_all(c
);
1181 pa_scache_free_all(c
);
1184 pa_log_info(_("Daemon terminated."));
1187 if (!conf
->no_cpu_limit
)
1188 pa_cpu_limit_done();
1193 /* If we have daemon_pipe[1] still open, this means we've failed after
1194 * the first fork, but before the second. Therefore just write to it. */
1195 if (daemon_pipe
[1] >= 0)
1196 pa_loop_write(daemon_pipe
[1], &retval
, sizeof(retval
), NULL
);
1197 else if (daemon_pipe2
[1] >= 0)
1198 pa_loop_write(daemon_pipe2
[1], &retval
, sizeof(retval
), NULL
);
1200 pa_close_pipe(daemon_pipe2
);
1201 pa_close_pipe(daemon_pipe
);
1205 pa_mainloop_free(mainloop
);
1208 pa_daemon_conf_free(conf
);
1211 pa_pid_file_remove();
1213 /* This has no real purpose except making things valgrind-clean */
1214 pa_unset_env_recorded();