VirtualBox

Changeset 4860 in vbox


Ignore:
Timestamp:
Sep 17, 2007 3:45:24 PM (17 years ago)
Author:
vboxsync
Message:

Activated the full backdoor logger in release builds of the Linux Guest Additions kernel modules

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/iprt/log.h

    r4351 r4860  
    529529    do {  LogTrace(); LogFlow(m); } while (0)
    530530
     531/** @def LogFunc
     532 * Level 1 logging inside C/C++ functions.
     533 * Prepends the given log message with the function name followed by a semicolon
     534 * and space.
     535 * @param m    log message in format <tt>("string\n" [, args])</tt>
     536 * @todo use a Log macro with a variable argument list (requires MSVC8) to
     537 * join two separate Log* calls and make this op atomic
     538 */
     539#define LogFunc(m) \
     540    do { Log(("%s: ", __PRETTY_FUNCTION__)); Log(m); } while (0)
     541
     542/** @def LogThisFunc
     543 * The same as LogFunc but for class functions (methods): the resulting log
     544 * line is additionally perpended with a hex value of |this| pointer.
     545 * @param m    log message in format <tt>("string\n" [, args])</tt>
     546 * @todo use a Log macro with a variable argument list (requires MSVC8) to
     547 * join two separate Log* calls and make this op atomic
     548 */
     549#define LogThisFunc(m) \
     550    do { Log(("{%p} %s: ", this, __PRETTY_FUNCTION__)); Log(m); } while (0)
     551
    531552/** @def LogFlowFunc
    532553 * Macro to log the execution flow inside C/C++ functions.
  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestLog.h

    r4731 r4860  
    2222#if defined(RT_OS_LINUX)
    2323
    24 /* Since I don't know the background for the stuff below, I prefer not to change
    25    it.  I don't need it or want it for backdoor logging inside the Linux
    26    Guest Additions kernel modules though. */
     24/* Since I don't know the background for the stuff below, I prefer not to
     25   change it.  I don't need it or want it for backdoor logging inside the
     26   Linux Guest Additions kernel modules though. */
    2727# include <VBox/log.h>
    28 # define LogRelPrint(a) \
    29       do { \
    30           RTLogWriteUser (a, strlen(a)); \
    31       } while (0)
    32 
    33 # define LogRelPrintQuote(a) \
    34       do { \
    35           LogRelPrint (#a); \
    36       } while (0)
    37 
    38 # define LogRelPrintFunc(a) \
    39       do { \
    40           LogRelPrint (__PRETTY_FUNCTION__); \
    41           LogRelPrint (": "); \
    42           LogRelPrint (a); \
    43       } while (0)
    44 
    45 # define LogFunc(a) \
    46       do { \
    47           Log(("%s: ", __PRETTY_FUNCTION__)); \
    48           Log(a); \
    49       } while (0)
    5028
    5129#else  /* RT_OS_LINUX not defined */
  • trunk/src/VBox/Additions/linux/module/Makefile.module

    r4780 r4860  
    3333        udivdi3.o \
    3434        umoddi3.o \
    35         qdivrem.o
    36 ifeq ($(BUILD_TYPE),debug)
    37 OBJS  += \
     35        qdivrem.o \
    3836        logbackdoor.o \
    3937        logformat.o \
     
    4139        strformatrt.o \
    4240        strformat-vbox.o
    43 endif
    4441
    4542ifneq ($(MAKECMDGOALS),clean)
  • trunk/src/VBox/Additions/linux/module/vboxmod.c

    r4745 r4860  
    2525#include <VBox/log.h>
    2626
    27 #define VERSION "0.5"
    28 
    2927MODULE_DESCRIPTION("VirtualBox Guest Additions for Linux Module");
    3028MODULE_AUTHOR("innotek GmbH");
     
    3836                        const char *pszFile, const char *pszFunction)
    3937{
    40     elog("!!Assertion Failed!!\n"
    41          "Expression: %s\n"
    42          "Location  : %s(%d) %s\n",
    43          pszExpr, pszFile, uLine, pszFunction);
    4438    Log(("!!Assertion Failed!!\n"
    4539         "Expression: %s\n"
     
    5852    vsnprintf(msg, sizeof(msg) - 1, pszFormat, ap);
    5953    msg[sizeof(msg) - 1] = '\0';
    60     elog("%s", msg);
    6154    Log(("%s", msg));
    6255    va_end(ap);
     
    6962}
    7063EXPORT_SYMBOL(RTAssertDoBreakpoint);
    71 #if !defined(DEBUG) && defined(IN_MODULE)
    72 /** Write a string to the backdoor logger. */
    73 RTDECL(void) RTLogWriteUser(const char *pch, size_t cb)
    74 {
    75     const uint8_t *pu8;
    76     for (pu8 = (const uint8_t *)pch; cb-- > 0; pu8++)
    77         ASMOutU8(RTLOG_DEBUG_PORT, *pu8);
    78     /** @todo a rep outs could be more efficient, I don't know...
    79      * @code
    80      * __asm {
    81      *      mov     ecx, [cb]
    82      *      mov     esi, [pch]
    83      *      mov     dx, RTLOG_DEFAULT_PORT
    84      *      rep outsb
    85      * }
    86      * @endcode
    87      */
    88 }
    89 EXPORT_SYMBOL(RTLogWriteUser);
    90 #endif /* DEBUG not defined and IN_MODULE defined */
    9164
    9265/** device extension structure (we only support one device instance) */
     
    670643    VMMDevReportGuestInfo *infoReq = NULL;
    671644
    672     printk(KERN_INFO "vboxadd: initializing version %s\n", VERSION);
     645    printk(KERN_INFO "vboxadd: initializing version %s\n", VBOX_VERSION_STRING);
     646    LogRel(("Starting VirtualBox Guest Additions version %s\n",
     647            VBOX_VERSION_STRING));
    673648
    674649    if (vboxadd_cmc_init ())
  • trunk/src/VBox/Additions/linux/sharedfolders/dirops.c

    r4822 r4860  
    4242
    4343        if (!sf_d) {
    44                 LogRelPrintFunc("could not allocate directory info for");
    45                 LogRelPrint(sf_i->path->String.utf8);
    46                 LogRelPrint("\n");
     44                LogRelFunc(("could not allocate directory info for %s\n",
     45                            sf_i->path->String.utf8));
    4746                return -ENOMEM;
    4847        }
     
    211210                fake_ino = sanity;
    212211                if (sanity - fake_ino) {
    213                         LogRelPrintFunc("can not compute ino\n");
     212                        LogRelFunc(("can not compute ino\n"));
    214213                        return -EINVAL;
    215214                }
     
    286285                sf_new_i = kmalloc (sizeof (*sf_new_i), GFP_KERNEL);
    287286                if (!sf_new_i) {
    288                         LogRelPrintFunc("could not allocate memory for new inode info\n");
     287                        LogRelFunc(("could not allocate memory for new inode info\n"));
    289288                        err = -ENOMEM;
    290289                        goto fail1;
     
    337336        sf_new_i = kmalloc (sizeof (*sf_new_i), GFP_KERNEL);
    338337        if (!sf_new_i) {
    339                 LogRelPrintFunc("could not allocate inode info.  caller=");
    340                 LogRelPrint(caller);
    341                 LogRelPrint("\n");
     338                LogRelFunc(("could not allocate inode info.  caller=%s\n", caller));
    342339                err = -ENOMEM;
    343340                goto fail0;
  • trunk/src/VBox/Additions/linux/sharedfolders/regops.c

    r4743 r4860  
    6565        tmp = kmalloc (CHUNK_SIZE, GFP_KERNEL);
    6666        if (!tmp) {
    67                 LogRelPrintFunc("could not allocate bounce buffer memory ");
    68                 LogRelPrintQuote(CHUNK_SIZE);
    69                 LogRelPrint(" bytes\n");
     67                LogRelFunc(("could not allocate bounce buffer memory %d bytes\n", CHUNK_SIZE));
    7068                return -ENOMEM;
    7169        }
     
    137135        tmp = kmalloc (CHUNK_SIZE, GFP_KERNEL);
    138136        if (!tmp) {
    139                 LogRelPrintFunc("could not allocate bounce buffer memory ");
    140                 LogRelPrintQuote(CHUNK_SIZE);
    141                 LogRelPrint("bytes\n");
     137                LogRelFunc(("could not allocate bounce buffer memory %d\n", CHUNK_SIZE));
    142138                return -ENOMEM;
    143139        }
     
    205201        sf_r = kmalloc (sizeof (*sf_r), GFP_KERNEL);
    206202        if (!sf_r) {
    207                 LogRelPrintFunc("could not allocate reg info\n");
     203                LogRelFunc(("could not allocate reg info\n"));
    208204                return -ENOMEM;
    209205        }
     
    223219                /* We ignore O_EXCL, as the Linux kernel seems to call create
    224220                   beforehand itself, so O_EXCL should always fail. */
    225 //                if (file->f_flags & O_EXCL) {
    226 //                        LogFunc(("O_EXCL set\n"));
    227 //                        params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
    228 //                }
    229 //                else {
    230                         /* O_TRUNC combined with O_EXCL is undefined. */
    231                         if (file->f_flags & O_TRUNC) {
    232                                 LogFunc(("O_TRUNC set\n"));
    233                                 params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
    234                         }
    235                         else {
    236                                 params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
    237                         }
    238 //                }
     221                if (file->f_flags & O_TRUNC) {
     222                        LogFunc(("O_TRUNC set\n"));
     223                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
     224                }
     225                else {
     226                        params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
     227                }
    239228        }
    240229        else {
     
    248237        if (!(params.CreateFlags & SHFL_CF_ACCESS_READWRITE)) {
    249238                switch (file->f_flags & O_ACCMODE) {
    250                         case O_RDONLY:
    251                                 params.CreateFlags |= SHFL_CF_ACCESS_READ;
    252                                 break;
    253 
    254                         case O_WRONLY:
    255                                 params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
    256                                 break;
    257 
    258                         case O_RDWR:
    259                                 params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
    260                                 break;
    261 
    262                         default:
    263                                 BUG ();
     239                case O_RDONLY:
     240                        params.CreateFlags |= SHFL_CF_ACCESS_READ;
     241                        break;
     242
     243                case O_WRONLY:
     244                        params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
     245                        break;
     246
     247                case O_RDWR:
     248                        params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
     249                        break;
     250
     251                default:
     252                        BUG ();
    264253                }
    265254        }
     
    273262                         file->f_flags, params.CreateFlags, rc));
    274263                kfree (sf_r);
    275                 return -EPROTO;
     264                return -RTErrConvertToErrno(rc);
    276265        }
    277266
     
    347336        page = alloc_page (GFP_HIGHUSER);
    348337        if (!page) {
    349                 LogRelPrintFunc("failed to allocate page\n");
     338                LogRelFunc(("failed to allocate page\n"));
    350339                SET_TYPE (VM_FAULT_OOM);
    351340                return NOPAGE_OOM;
  • trunk/src/VBox/Additions/linux/sharedfolders/utils.c

    r4822 r4860  
    251251        tmp = kmalloc (shflstring_len, GFP_KERNEL);
    252252        if (!tmp) {
    253                 LogRelPrintFunc("kmalloc failed, caller=");
    254                 LogRelPrint(caller);
     253                LogRelFunc(("kmalloc failed, caller=%s\n", caller));
    255254                return -ENOMEM;
    256255        }
     
    419418        b = kmalloc (sizeof (*b), GFP_KERNEL);
    420419        if (!b) {
    421                 LogRelPrintFunc("could not alloc directory buffer\n");
     420                LogRelFunc(("could not alloc directory buffer\n"));
    422421                return NULL;
    423422        }
     
    430429        if (!b->buf) {
    431430                kfree (b);
    432                 LogRelPrintFunc("could not alloc directory buffer storage\n");
     431                LogRelFunc(("could not alloc directory buffer storage\n"));
    433432                return NULL;
    434433        }
     
    480479        p = kmalloc (sizeof (*p), GFP_KERNEL);
    481480        if (!p) {
    482                 LogRelPrintFunc("could not alloc directory info\n");
     481                LogRelFunc(("could not alloc directory info\n"));
    483482                return NULL;
    484483        }
     
    536535                        if (!b) {
    537536                                err = -ENOMEM;
    538                                 LogRelPrintFunc("could not alloc directory buffer\n");
     537                                LogRelFunc(("could not alloc directory buffer\n"));
    539538                                goto fail1;
    540539                        }
  • trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c

    r4743 r4860  
    7373        if (!sf_g) {
    7474                err = -ENOMEM;
    75                 LogRelPrintFunc("could not allocate memory for global info\n");
     75                LogRelFunc(("could not allocate memory for global info\n"));
    7676                goto fail0;
    7777        }
     
    9191        if (!str_name) {
    9292                err = -ENOMEM;
    93                 LogRelPrintFunc("could not allocate memory for host name\n");
     93                LogRelFunc(("could not allocate memory for host name\n"));
    9494                goto fail1;
    9595        }
     
    196196        if (!sf_i) {
    197197                err = -ENOMEM;
    198                 LogRelPrintFunc ("could not allocate memory for root inode info\n");
     198                LogRelFunc (("could not allocate memory for root inode info\n"));
    199199                goto fail1;
    200200        }
     
    203203        if (!sf_i->path) {
    204204                err = -ENOMEM;
    205                 LogRelPrintFunc ("could not allocate memory for root inode path\n");
     205                LogRelFunc (("could not allocate memory for root inode path\n"));
    206206                goto fail2;
    207207        }
     
    418418        rc = vboxInit ();
    419419        if (VBOX_FAILURE (rc)) {
    420                 LogRelPrintFunc ("vboxInit failed\n");
    421                 Log (("rc=%d\n", rc));
     420                LogRelFunc (("vboxInit failed, rc=%d\n", rc));
    422421                goto fail0;
    423422        }
     
    425424        rc = vboxConnect (&client_handle);
    426425        if (VBOX_FAILURE (rc)) {
    427                 LogRelPrintFunc ("vboxConnect failed\n");
    428                 Log (("rc=%d\n", rc));
     426                LogRelFunc (("vboxConnect failed, rc=%d\n", rc));
    429427                goto fail1;
    430428        }
     
    432430        rc = vboxCallSetUtf8 (&client_handle);
    433431        if (VBOX_FAILURE (rc)) {
    434                 LogRelPrintFunc ("vboxCallSetUtf8 failed\n");
    435                 Log (("rc=%d\n", rc));
     432                LogRelFunc (("vboxCallSetUtf8 failed, rc=%d\n", rc));
    436433                goto fail2;
    437434        }
  • trunk/src/VBox/Runtime/VBox/logbackdoor.cpp

    r4802 r4860  
    8484 */
    8585# include <linux/module.h>
    86 # ifdef DEBUG
    87 /* We only export the full logging infrastructure to the guest kernel
    88    modules in debug builds. */
    8986EXPORT_SYMBOL(RTLogBackdoorPrintf);
    90 # endif
    9187EXPORT_SYMBOL(RTLogWriteUser);
    9288#endif /* RT_OS_LINUX && IN_MODULE */
    93 
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette