2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Elrond 2002
6 Copyright (C) Simo Sorce 2002
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "system/syslog.h"
26 #include "system/locale.h"
27 #include "time_basic.h"
28 #include "close_low_fd.h"
30 #include "samba_util.h" /* LIST_SEP */
33 /* define what facility to use for syslog */
34 #ifndef SYSLOG_FACILITY
35 #define SYSLOG_FACILITY LOG_DAEMON
38 /* -------------------------------------------------------------------------- **
41 * FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
42 * format_bufr[FORMAT_BUFR_MAX] should always be reserved
43 * for a terminating null byte.
46 #define FORMAT_BUFR_SIZE 1024
47 #define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
49 /* -------------------------------------------------------------------------- **
50 * This module implements Samba's debugging utility.
52 * The syntax of a debugging log file is represented as:
54 * <debugfile> :== { <debugmsg> }
56 * <debugmsg> :== <debughdr> '\n' <debugtext>
58 * <debughdr> :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
60 * <debugtext> :== { <debugline> }
62 * <debugline> :== TEXT '\n'
64 * TEXT is a string of characters excluding the newline character.
65 * LEVEL is the DEBUG level of the message (an integer in the range 0..10).
66 * TIME is a timestamp.
67 * FILENAME is the name of the file from which the debug message was generated.
68 * FUNCTION is the function from which the debug message was generated.
70 * Basically, what that all means is:
72 * - A debugging log file is made up of debug messages.
74 * - Each debug message is made up of a header and text. The header is
75 * separated from the text by a newline.
77 * - The header begins with the timestamp and debug level of the message
78 * enclosed in brackets. The filename and function from which the
79 * message was generated may follow. The filename is terminated by a
80 * colon, and the function name is terminated by parenthesis.
82 * - The message text is made up of zero or more lines, each terminated by
86 /* state variables for the debug system */
89 int fd; /* The log file handle */
90 enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
91 const char *prog_name;
93 bool schedule_reopen_logs;
95 struct debug_settings settings;
97 debug_callback_fn callback;
98 void *callback_private;
101 .timestamp_logs = true
103 .fd = 2 /* stderr by default */
106 /* -------------------------------------------------------------------------- **
107 * External variables.
111 used to check if the user specified a
112 logfile on the command line
114 bool override_logfile;
117 * This is to allow reading of DEBUGLEVEL_CLASS before the debug
118 * system has been initialized.
120 static const int debug_class_list_initial[DBGC_MAX_FIXED + 1];
122 static int debug_num_classes = 0;
123 int *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
126 /* -------------------------------------------------------------------------- **
127 * Internal variables.
129 * debug_count - Number of debug messages that have been output.
130 * Used to check log size.
132 * current_msg_level - Internal copy of the message debug level. Written by
133 * dbghdr() and read by Debug1().
135 * format_bufr - Used to format debug messages. The dbgtext() function
136 * prints debug messages to a string, and then passes the
137 * string to format_debug_text(), which uses format_bufr
138 * to build the formatted output.
140 * format_pos - Marks the first free byte of the format_bufr.
143 * log_overflow - When this variable is true, never attempt to check the
144 * size of the log. This is a hack, so that we can write
145 * a message using DEBUG, from open_logs() when we
146 * are unable to open a new log file for some reason.
149 static int debug_count = 0;
150 static int current_msg_level = 0;
151 static char format_bufr[FORMAT_BUFR_SIZE];
152 static size_t format_pos = 0;
153 static bool log_overflow = false;
156 * Define all the debug class selection names here. Names *MUST NOT* contain
157 * white space. There must be one name for each DBGC_<class name>, and they
158 * must be in the table in the order of DBGC_<class name>..
160 static const char *default_classname_table[] = {
161 "all", /* DBGC_ALL; index refs traditional DEBUGLEVEL */
162 "tdb", /* DBGC_TDB */
163 "printdrivers", /* DBGC_PRINTDRIVERS */
164 "lanman", /* DBGC_LANMAN */
165 "smb", /* DBGC_SMB */
166 "rpc_parse", /* DBGC_RPC_PARSE */
167 "rpc_srv", /* DBGC_RPC_SRV */
168 "rpc_cli", /* DBGC_RPC_CLI */
169 "passdb", /* DBGC_PASSDB */
170 "sam", /* DBGC_SAM */
171 "auth", /* DBGC_AUTH */
172 "winbind", /* DBGC_WINBIND */
173 "vfs", /* DBGC_VFS */
174 "idmap", /* DBGC_IDMAP */
175 "quota", /* DBGC_QUOTA */
176 "acls", /* DBGC_ACLS */
177 "locking", /* DBGC_LOCKING */
178 "msdfs", /* DBGC_MSDFS */
179 "dmapi", /* DBGC_DMAPI */
180 "registry", /* DBGC_REGISTRY */
181 "scavenger", /* DBGC_SCAVENGER */
182 "dns", /* DBGC_DNS */
183 "ldb", /* DBGC_LDB */
187 static char **classname_table = NULL;
190 /* -------------------------------------------------------------------------- **
194 static void debug_init(void);
196 /***************************************************************************
197 Free memory pointed to by global pointers.
198 ****************************************************************************/
200 void gfree_debugsyms(void)
202 TALLOC_FREE(classname_table);
204 if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
205 TALLOC_FREE( DEBUGLEVEL_CLASS );
206 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
209 debug_num_classes = 0;
211 state.initialized = false;
214 /****************************************************************************
215 utility lists registered debug class names's
216 ****************************************************************************/
218 char *debug_list_class_names_and_levels(void)
222 /* prepare strings */
223 for (i = 0; i < debug_num_classes; i++) {
224 buf = talloc_asprintf_append(buf,
228 i == (debug_num_classes - 1) ? "\n" : " ");
236 /****************************************************************************
237 Utility to translate names to debug class index's (internal version).
238 ****************************************************************************/
240 static int debug_lookup_classname_int(const char* classname)
244 if (!classname) return -1;
246 for (i=0; i < debug_num_classes; i++) {
247 if (strcmp(classname, classname_table[i])==0)
253 /****************************************************************************
254 Add a new debug class to the system.
255 ****************************************************************************/
257 int debug_add_class(const char *classname)
261 char **new_name_list;
267 /* check the init has yet been called */
270 ndx = debug_lookup_classname_int(classname);
273 ndx = debug_num_classes;
275 if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
276 /* Initial loading... */
277 new_class_list = NULL;
279 new_class_list = DEBUGLEVEL_CLASS;
282 default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
284 new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
287 DEBUGLEVEL_CLASS = new_class_list;
289 DEBUGLEVEL_CLASS[ndx] = default_level;
291 new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
294 classname_table = new_name_list;
296 classname_table[ndx] = talloc_strdup(classname_table, classname);
297 if (! classname_table[ndx])
300 debug_num_classes = ndx + 1;
305 /****************************************************************************
306 Utility to translate names to debug class index's (public version).
307 ****************************************************************************/
309 int debug_lookup_classname(const char *classname)
313 if (!classname || !*classname)
316 ndx = debug_lookup_classname_int(classname);
321 DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
323 return debug_add_class(classname);
326 /****************************************************************************
327 Dump the current registered debug levels.
328 ****************************************************************************/
330 static void debug_dump_status(int level)
334 DEBUG(level, ("INFO: Current debug levels:\n"));
335 for (q = 0; q < debug_num_classes; q++) {
336 const char *classname = classname_table[q];
337 DEBUGADD(level, (" %s: %d\n",
339 DEBUGLEVEL_CLASS[q]));
343 static bool debug_parse_param(char *param)
350 class_name = strtok_r(param, ":", &saveptr);
351 if (class_name == NULL) {
355 class_level = strtok_r(NULL, "\0", &saveptr);
356 if (class_level == NULL) {
360 ndx = debug_lookup_classname(class_name);
365 DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
370 /****************************************************************************
371 Parse the debug levels from smb.conf. Example debug level string:
372 3 tdb:5 printdrivers:7
373 Note: the 1st param has no "name:" preceeding it.
374 ****************************************************************************/
376 bool debug_parse_levels(const char *params_str)
378 size_t str_len = strlen(params_str);
386 memcpy(str, params_str, str_len+1);
388 tok = strtok_r(str, LIST_SEP, &saveptr);
393 /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
394 * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
396 if (isdigit(tok[0])) {
397 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(tok);
398 tok = strtok_r(NULL, LIST_SEP, &saveptr);
400 DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
403 /* Array is debug_num_classes long */
404 for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
405 DEBUGLEVEL_CLASS[i] = DEBUGLEVEL_CLASS[DBGC_ALL];
408 while (tok != NULL) {
411 ok = debug_parse_param(tok);
413 DEBUG(0,("debug_parse_params: unrecognized debug "
414 "class name or format [%s]\n", tok));
418 tok = strtok_r(NULL, LIST_SEP, &saveptr);
421 debug_dump_status(5);
426 /* setup for logging of talloc warnings */
427 static void talloc_log_fn(const char *msg)
429 DEBUG(0,("%s", msg));
432 void debug_setup_talloc_log(void)
434 talloc_set_log_fn(talloc_log_fn);
438 /****************************************************************************
439 Init debugging (one time stuff)
440 ****************************************************************************/
442 static void debug_init(void)
446 if (state.initialized)
449 state.initialized = true;
451 debug_setup_talloc_log();
453 for(p = default_classname_table; *p; p++) {
458 /* This forces in some smb.conf derived values into the debug system.
459 * There are no pointers in this structure, so we can just
460 * structure-assign it in */
461 void debug_set_settings(struct debug_settings *settings)
463 state.settings = *settings;
467 control the name of the logfile and whether logging will be to stdout, stderr
468 or a file, and set up syslog
470 new_log indicates the destination for the debug log (an enum in
471 order of precedence - once set to DEBUG_FILE, it is not possible to
472 reset to DEBUG_STDOUT for example. This makes it easy to override
473 for debug to stderr on the command line, as the smb.conf cannot
474 reset it back to file-based logging
476 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
479 if (state.logtype < new_logtype) {
480 state.logtype = new_logtype;
483 state.prog_name = prog_name;
485 reopen_logs_internal();
487 if (state.logtype == DEBUG_FILE) {
489 const char *p = strrchr(prog_name, '/');
493 openlog( prog_name, LOG_PID, SYSLOG_FACILITY );
495 /* for old systems that have no facility codes. */
496 openlog( prog_name, LOG_PID );
502 /***************************************************************************
503 Set the logfile name.
504 **************************************************************************/
506 void debug_set_logfile(const char *name)
508 if (name == NULL || *name == 0) {
509 /* this copes with calls when smb.conf is not loaded yet */
512 TALLOC_FREE(state.debugf);
513 state.debugf = talloc_strdup(NULL, name);
516 static void debug_close_fd(int fd)
523 bool debug_get_output_is_stderr(void)
525 return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
528 bool debug_get_output_is_stdout(void)
530 return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
533 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
537 state.logtype = DEBUG_CALLBACK;
538 state.callback_private = private_ptr;
541 state.logtype = DEBUG_DEFAULT_STDERR;
542 state.callback_private = NULL;
543 state.callback = NULL;
547 /**************************************************************************
549 note that we now do this unconditionally
550 We attempt to open the new debug fp before closing the old. This means
551 if we run out of fd's we just keep using the old fd rather than aborting.
552 Fix from dgibson@linuxcare.com.
553 **************************************************************************/
556 reopen the log file (usually called because the log file name might have changed)
558 bool reopen_logs_internal(void)
565 if (state.reopening_logs) {
569 /* Now clear the SIGHUP induced flag */
570 state.schedule_reopen_logs = false;
572 switch (state.logtype) {
576 case DEBUG_DEFAULT_STDOUT:
577 debug_close_fd(state.fd);
581 case DEBUG_DEFAULT_STDERR:
583 debug_close_fd(state.fd);
591 oldumask = umask( 022 );
597 state.reopening_logs = true;
599 new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
603 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
604 log_overflow = false;
609 debug_close_fd(old_fd);
612 /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
613 * to fix problem where smbd's that generate less
614 * than 100 messages keep growing the log.
616 force_check_log_size();
617 (void)umask(oldumask);
619 /* Take over stderr to catch output into logs */
621 if (dup2(state.fd, 2) == -1) {
622 /* Close stderr too, if dup2 can't point it -
623 at the logfile. There really isn't much
624 that can be done on such a fundamental
630 state.reopening_logs = false;
635 /**************************************************************************
636 Force a check of the log size.
637 ***************************************************************************/
639 void force_check_log_size( void )
644 _PUBLIC_ void debug_schedule_reopen_logs(void)
646 state.schedule_reopen_logs = true;
650 /***************************************************************************
651 Check to see if there is any need to check if the logfile has grown too big.
652 **************************************************************************/
654 bool need_to_check_log_size( void )
658 if( debug_count < 100)
661 maxlog = state.settings.max_log_size * 1024;
662 if ( state.fd <=2 || maxlog <= 0 ) {
669 /**************************************************************************
670 Check to see if the log has grown to be too big.
671 **************************************************************************/
673 void check_log_size( void )
679 * We need to be root to check/change log-file, skip this and let the main
680 * loop check do a new check as root.
683 #if _SAMBA_BUILD_ == 3
684 if (geteuid() != sec_initial_uid())
689 /* We don't check sec_initial_uid() here as it isn't
690 * available in common code and we don't generally
691 * want to rotate and the possibly lose logs in
692 * make test or the build farm */
696 if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
700 maxlog = state.settings.max_log_size * 1024;
702 if (state.schedule_reopen_logs) {
703 (void)reopen_logs_internal();
706 if (maxlog && (fstat(state.fd, &st) == 0
707 && st.st_size > maxlog )) {
708 (void)reopen_logs_internal();
709 if (state.fd > 2 && (fstat(state.fd, &st) == 0
710 && st.st_size > maxlog)) {
713 if (asprintf(&name, "%s.old", state.debugf ) < 0) {
716 (void)rename(state.debugf, name);
718 if (!reopen_logs_internal()) {
719 /* We failed to reopen a log - continue using the old name. */
720 (void)rename(name, state.debugf);
727 * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
731 /* This code should only be reached in very strange
732 * circumstances. If we merely fail to open the new log we
733 * should stick with the old one. ergo this should only be
734 * reached when opening the logs for the first time: at
735 * startup or when the log level is increased from zero.
738 int fd = open( "/dev/console", O_WRONLY, 0);
741 DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
745 * We cannot continue without a debug file handle.
753 /*************************************************************************
754 Write an debug message on the debugfile.
755 This is called by dbghdr() and format_debug_text().
756 ************************************************************************/
758 static int Debug1(const char *msg)
760 int old_errno = errno;
764 if (state.logtype == DEBUG_CALLBACK) {
765 size_t msg_len = strlen(msg);
766 char msg_copy[msg_len];
768 if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
769 memcpy(msg_copy, msg, msg_len-1);
770 msg_copy[msg_len-1] = '\0';
774 state.callback(state.callback_private, current_msg_level, msg);
778 if ( state.logtype != DEBUG_FILE ) {
780 write(state.fd, msg, strlen(msg));
786 if( !state.settings.syslog_only)
789 if( state.fd <= 0 ) {
790 mode_t oldumask = umask( 022 );
791 int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
792 (void)umask( oldumask );
802 if( current_msg_level < state.settings.syslog ) {
803 /* map debug levels to syslog() priorities
804 * note that not all DEBUG(0, ...) calls are
805 * necessarily errors */
806 static const int priority_map[4] = {
814 if( current_msg_level >= ARRAY_SIZE(priority_map) || current_msg_level < 0)
815 priority = LOG_DEBUG;
817 priority = priority_map[current_msg_level];
820 * Specify the facility to interoperate with other syslog
821 * callers (vfs_full_audit for example).
823 priority |= SYSLOG_FACILITY;
825 syslog(priority, "%s", msg);
832 if( !state.settings.syslog_only)
836 write(state.fd, msg, strlen(msg));
847 /**************************************************************************
848 Print the buffer content via Debug1(), then reset the buffer.
851 ****************************************************************************/
853 static void bufr_print( void )
855 format_bufr[format_pos] = '\0';
856 (void)Debug1(format_bufr);
860 /***************************************************************************
861 Format the debug message text.
863 Input: msg - Text to be added to the "current" debug message text.
867 Notes: The purpose of this is two-fold. First, each call to syslog()
868 (used by Debug1(), see above) generates a new line of syslog
869 output. This is fixed by storing the partial lines until the
870 newline character is encountered. Second, printing the debug
871 message lines when a newline is encountered allows us to add
872 spaces, thus indenting the body of the message and making it
874 **************************************************************************/
876 static void format_debug_text( const char *msg )
879 bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
883 for( i = 0; msg[i]; i++ ) {
884 /* Indent two spaces at each new line. */
885 if(timestamp && 0 == format_pos) {
886 format_bufr[0] = format_bufr[1] = ' ';
890 /* If there's room, copy the character to the format buffer. */
891 if( format_pos < FORMAT_BUFR_MAX )
892 format_bufr[format_pos++] = msg[i];
894 /* If a newline is encountered, print & restart. */
898 /* If the buffer is full dump it out, reset it, and put out a line
899 * continuation indicator.
901 if( format_pos >= FORMAT_BUFR_MAX ) {
903 (void)Debug1( " +>\n" );
907 /* Just to be safe... */
908 format_bufr[format_pos] = '\0';
911 /***************************************************************************
912 Flush debug output, including the format buffer content.
916 ***************************************************************************/
918 void dbgflush( void )
923 /***************************************************************************
924 Print a Debug Header.
926 Input: level - Debug level of the message (not the system-wide debug
928 cls - Debuglevel class of the calling module.
929 file - Pointer to a string containing the name of the file
930 from which this function was called, or an empty string
931 if the __FILE__ macro is not implemented.
932 func - Pointer to a string containing the name of the function
933 from which this function was called, or an empty string
934 if the __FUNCTION__ macro is not implemented.
935 line - line number of the call to dbghdr, assuming __LINE__
938 Output: Always true. This makes it easy to fudge a call to dbghdr()
939 in a macro, since the function can be called as part of a test.
940 Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
942 Notes: This function takes care of setting current_msg_level.
944 ****************************************************************************/
946 bool dbghdrclass(int level, int cls, const char *location, const char *func)
948 /* Ensure we don't lose any real errno value. */
949 int old_errno = errno;
950 bool verbose = false;
951 char header_str[300];
954 struct timeval_buf tvbuf;
957 /* This is a fudge. If there is stuff sitting in the format_bufr, then
958 * the *right* thing to do is to call
959 * format_debug_text( "\n" );
960 * to write the remainder, and then proceed with the new header.
961 * Unfortunately, there are several places in the code at which
962 * the DEBUG() macro is used to build partial lines. That in mind,
963 * we'll work under the assumption that an incomplete line indicates
964 * that a new header is *not* desired.
969 /* Set current_msg_level. */
970 current_msg_level = level;
972 /* Don't print a header if we're logging to stdout. */
973 if ( state.logtype != DEBUG_FILE ) {
977 /* Print the header if timestamps are turned on. If parameters are
978 * not yet loaded, then default to timestamps on.
980 if (!(state.settings.timestamp_logs ||
981 state.settings.debug_prefix_timestamp)) {
986 timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
989 hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
991 if (hs_len >= sizeof(header_str)) {
995 if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
999 if (verbose || state.settings.debug_pid) {
1001 header_str + hs_len, sizeof(header_str) - hs_len,
1002 ", pid=%u", (unsigned int)getpid());
1003 if (hs_len >= sizeof(header_str)) {
1008 if (verbose || state.settings.debug_uid) {
1010 header_str + hs_len, sizeof(header_str) - hs_len,
1011 ", effective(%u, %u), real(%u, %u)",
1012 (unsigned int)geteuid(), (unsigned int)getegid(),
1013 (unsigned int)getuid(), (unsigned int)getgid());
1014 if (hs_len >= sizeof(header_str)) {
1019 if ((verbose || state.settings.debug_class)
1020 && (cls != DBGC_ALL)) {
1022 header_str + hs_len, sizeof(header_str) - hs_len,
1023 ", class=%s", classname_table[cls]);
1024 if (hs_len >= sizeof(header_str)) {
1030 * No +=, see man man strlcat
1032 hs_len = strlcat(header_str, "] ", sizeof(header_str));
1033 if (hs_len >= sizeof(header_str)) {
1037 if (!state.settings.debug_prefix_timestamp) {
1039 header_str + hs_len, sizeof(header_str) - hs_len,
1040 "%s(%s)\n", location, func);
1041 if (hs_len >= sizeof(header_str)) {
1047 (void)Debug1(header_str);
1053 /***************************************************************************
1054 Add text to the body of the "current" debug message via the format buffer.
1056 Input: format_str - Format string, as used in printf(), et. al.
1057 ... - Variable argument list.
1059 ..or.. va_alist - Old style variable parameter list starting point.
1061 Output: Always true. See dbghdr() for more info, though this is not
1062 likely to be used in the same way.
1064 ***************************************************************************/
1066 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1067 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1069 char *msgbuf = NULL;
1073 res = vasprintf(&msgbuf, format_str, ap);
1075 format_debug_text(msgbuf);
1083 bool dbgtext_va(const char *format_str, va_list ap)
1085 return __dbgtext_va(format_str, ap);
1088 bool dbgtext(const char *format_str, ... )
1093 va_start(ap, format_str);
1094 ret = __dbgtext_va(format_str, ap);