(file) Return to TraceFileHandlerPOSIX.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/TraceFileHandlerPOSIX.cpp between version 1.15 and 1.24

version 1.15, 2008/12/02 09:00:53 version 1.24, 2013/05/03 04:49:10
Line 32 
Line 32 
 #if defined(PEGASUS_OS_VMS) #if defined(PEGASUS_OS_VMS)
 # include <fcntl.h> # include <fcntl.h>
 #endif #endif
 #include <Pegasus/Common/Logger.h>  
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include <Pegasus/Common/TraceFileHandler.h> #include <Pegasus/Common/TraceFileHandler.h>
 #include <Pegasus/Common/Mutex.h> #include <Pegasus/Common/Mutex.h>
   #include <Pegasus/Common/StringConversion.h>
  
 PEGASUS_USING_STD; PEGASUS_USING_STD;
  
Line 49 
Line 49 
 //  Implementation of this function is platform specific //  Implementation of this function is platform specific
 /////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
  
 #if defined(PEGASUS_OS_VMS)  
  
 void TraceFileHandler::prepareFileHandle(void)  void TraceFileHandler::handleMessage(
       const char *message,
       Uint32,
       const char *fmt, va_list argList)
 { {
     Sint32 retCode;  
  
     if (_configHasChanged)     if (_configHasChanged)
     {     {
         _reConfigure();         _reConfigure();
     }     }
  
     // Check if the file has been deleted, if so re-open the file and  
     // continue  
     if (!System::exists(_fileName))  
     {  
         if (_fileHandle == 0)  
         {  
             _fileHandle = fopen(_fileName, "a+", "shr=get,put,upd");  
             // _fileHandle = fopen(_fileName,"a","shr=get");  
         }  
         else  
         {  
             _fileHandle =  
                 freopen(_fileName, "a+", _fileHandle, "shr=get,put,upd");  
             // _fileHandle = freopen(_fileName,"a",_fileHandle,"shr=get");  
         }  
         if (!_fileHandle)         if (!_fileHandle)
         {         {
             // Unable to re-open file, log a message          // The trace file is not open, which means an earlier fopen() was
           // unsuccessful.  Stop now to avoid logging duplicate error messages.
             Logger::put_l(  
                 Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,  
                 MessageLoaderParms(  
                     "Common.TraceFileHandlerUnix.FAILED_TO_OPEN_FILE",  
                     "Failed to open File $0",  
                     _fileName));  
             return;  
         }  
   
         // Set permissions on the trace file to 0400  
   
         if (!FileSystem::changeFilePermissions(  
                 String(_fileName), (S_IRUSR | S_IWUSR)))  
         {  
             Logger::put_l(  
                 Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,  
                 MessageLoaderParms(  
                     "Common.TraceFileHandlerUnix."  
                         "FAILED_TO_SET_FILE_PERMISSIONS",  
                     "Failed to set permissions on file $0",  
                     _fileName));  
             return;             return;
         }         }
     }  
     // Seek to the end of File  
     retCode = fseek(_fileHandle, 0, SEEK_END);  
 }  
  
 void TraceFileHandler::handleMessage(  
     const char *message,  
     Uint32 msgLen,  
     const char *fmt, va_list argList)  
 {  
     Sint32 retCode;  
     Sint32 fileDesc;  
  
     // Do not add Trace calls in the Critical section     // Do not add Trace calls in the Critical section
     // ---- BEGIN CRITICAL SECTION     // ---- BEGIN CRITICAL SECTION
       AutoMutex writeLock(writeMutex);
  
     prepareFileHandle();      if(!_fileExists(_fileName))
   
     // Write the message to the file  
   
     retCode = fprintf(_fileHandle, "%s", message);  
     retCode = vfprintf(_fileHandle, fmt, argList);  
     retCode = fprintf(_fileHandle, "\n");  
     retCode = fflush(_fileHandle);  
     fileDesc = fileno(_fileHandle);  
     retCode = fsync(fileDesc);  
     _wroteToLog = false;  
     // retCode = fclose(_fileHandle);  
     // _fileHandle = 0;  
   
     // ---- END CRITICAL SECTION  
   
     return;  
 }  
   
 void TraceFileHandler::handleMessage(const char *message, Uint32 msgLen)  
 { {
     Sint32 retCode;  
     Sint32 fileDesc;  
   
     // Do not add Trace calls in the Critical section  
     // ---- BEGIN CRITICAL SECTION  
   
     prepareFileHandle();  
   
     // Write the message to the file  
   
     retCode = fprintf(_fileHandle, "%s\n", message);  
     retCode = fflush(_fileHandle);  
     fileDesc = fileno(_fileHandle);  
     retCode = fsync(fileDesc);  
     _wroteToLog = false;  
     // retCode = fclose(_fileHandle);  
     // _fileHandle = 0;  
   
     // ---- END CRITICAL SECTION  
   
     return;     return;
 } }
  
       // Write the message to the file
       fprintf(_fileHandle, "%s", message);
       vfprintf(_fileHandle, fmt, argList);
       fprintf(_fileHandle, "\n");
  
 #else /* PEGASUS_OS_VMS */  #if defined(PEGASUS_OS_VMS)
       if (0 == fsync(fileno(_fileHandle)))
 void TraceFileHandler::prepareFileHandle(void)  #else
 {      if (0 == fflush(_fileHandle))
     // If the file has been deleted, re-open it and continue  #endif
     if (!System::exists(_fileName))  
     {  
         fclose(_fileHandle);  
         _fileHandle = _openFile(_fileName);  
         if (!_fileHandle)  
         {         {
             return;          // trace message successful written, reset error log messages
         }          // thus allow writing of errors to log again
           _logErrorBitField = 0;
     }     }
  
     // Got the Lock on the File. Seek to the end of File      // ---- END CRITICAL SECTION
     fseek(_fileHandle, 0, SEEK_END);  
 # ifdef PEGASUS_PLATFORM_LINUX_GENERIC_GNU  
     long pos = ftell(_fileHandle);  
     // Check if the file size is approaching 2GB - which is the  
     // maximum size a file on 32 bit Linux can grow (ofcourse if  
     // not using large-files option). If this is not checked, the  
     // cimserver may get a SIGXFSZ signal and shutdown. See Bug#1527.  
     if (pos >= 0x7ff00000)  
     {  
         // If the file size is almost 2 GB in size, close this trace  
         // file and open a new trace file which would have _fileCount  
         // as the suffix. So, if "cimserver.trc" is the trace file that  
         // approaches 2GB, the next file which gets created would be  
         // named "cimserver.trc.1" and so on ...  
         fclose(_fileHandle);  
         sprintf(_fileName, "%s.%u", _baseFileName, ++_fileCount);  
         _fileHandle = fopen(_fileName, "a+");  
         if (!_fileHandle)  
         {  
             // Unable to open file, log a message  
             if (!_wroteToLog)  
             {  
                 Logger::put_l(  
                     Logger::ERROR_LOG, System::CIMSERVER, Logger::WARNING,  
                     MessageLoaderParms(  
                         "Common.TraceFileHandler.FAILED_TO_OPEN_FILE",  
                         "Failed to open File $0",  
                         _fileName));  
                 _wroteToLog = true;  
             }  
             return;  
         }  
     }  
 # endif  
 } }
  
 void TraceFileHandler::handleMessage(  void TraceFileHandler::handleMessage(const char *message, Uint32)
     const char *message,  
     Uint32 msgLen,  
     const char *fmt, va_list argList)  
 { {
   
     if (_configHasChanged)     if (_configHasChanged)
     {     {
         _reConfigure();         _reConfigure();
Line 236 
Line 116 
     // ---- BEGIN CRITICAL SECTION     // ---- BEGIN CRITICAL SECTION
     AutoMutex writeLock(writeMutex);     AutoMutex writeLock(writeMutex);
  
     prepareFileHandle();      if(!_fileExists(_fileName))
     // Write the message to the file  
     fprintf(_fileHandle, "%s", message);  
     vfprintf(_fileHandle, fmt, argList);  
     fprintf(_fileHandle, "\n");  
     fflush(_fileHandle);  
     // ---- END CRITICAL SECTION  
 }  
   
 void TraceFileHandler::handleMessage(const char *message, Uint32 msgLen)  
 {  
     if (_configHasChanged)  
     {  
         _reConfigure();  
     }  
   
     if (!_fileHandle)  
     {     {
         // The trace file is not open, which means an earlier fopen() was  
         // unsuccessful.  Stop now to avoid logging duplicate error messages.  
         return;         return;
     }     }
  
     // Do not add Trace calls in the Critical section  
     // ---- BEGIN CRITICAL SECTION  
     AutoMutex writeLock(writeMutex);  
  
     prepareFileHandle();  
     // Write the message to the file     // Write the message to the file
     fprintf(_fileHandle, "%s\n", message);     fprintf(_fileHandle, "%s\n", message);
     fflush(_fileHandle);  #if defined(PEGASUS_OS_VMS)
       if (0 == fsync(fileno(_fileHandle)))
   #else
       if (0 == fflush(_fileHandle))
   #endif
       {
           // trace message successful written, reset error log messages
           // thus allow writing of errors to log again
           _logErrorBitField = 0;
       }
     // ---- END CRITICAL SECTION     // ---- END CRITICAL SECTION
 } }
  
   
 #endif /* !PEGASUS_OS_VMS */  
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.15  
changed lines
  Added in v.1.24
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2