|
1 /* |
|
2 * Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: This module defines event logger. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include <eikenv.h> |
|
21 #include <bautils.h> |
|
22 //#include "filesdef.h" |
|
23 #include "eventlogger.h" |
|
24 |
|
25 // |
|
26 //Class that writes logs events into a binary file |
|
27 |
|
28 CEventLogger::CEventLogger(CEventMediatorServer* aServer) |
|
29 { |
|
30 iServer = aServer; |
|
31 iFileMaxLength = KBYTES_TO_BYTES * LOGFILE_MAX_LTH; |
|
32 } |
|
33 |
|
34 CEventLogger* CEventLogger::NewL(CEventMediatorServer* aServer) |
|
35 { |
|
36 CEventLogger* server = new (ELeave) CEventLogger(aServer); |
|
37 return server; |
|
38 } |
|
39 |
|
40 CEventLogger::CEventLogger(TInt aFileMaxLength, CEventMediatorServer* aServer) |
|
41 { |
|
42 iServer = aServer; |
|
43 if ( aFileMaxLength == 0 || aFileMaxLength > LOGFILE_MAX_LTH ) |
|
44 iFileMaxLength = KBYTES_TO_BYTES * LOGFILE_MAX_LTH; |
|
45 else iFileMaxLength = KBYTES_TO_BYTES * aFileMaxLength; |
|
46 } |
|
47 |
|
48 CEventLogger::~CEventLogger() |
|
49 { |
|
50 } |
|
51 |
|
52 |
|
53 |
|
54 void CEventLogger::LogEvent(const TDesC8& aEvent) |
|
55 { |
|
56 TInt position; |
|
57 TInt log_elem_lth; |
|
58 TBuf8<EVENTLOG_FILE_HEADER_LTH> file_hdr; |
|
59 |
|
60 /*------------------------------------------------------------------- |
|
61 * Log an event into the binary file. File format: |
|
62 * 0 3 7 CL |
|
63 * +--------------------+--------------------+---------------------+ |
|
64 * ! File Id (FI)! Current length (CL)! Wrapping offset (WO)! |
|
65 * +--------------------+--------------------+---------------------+ |
|
66 * |
|
67 * +-----------------------+ |
|
68 * ! Curr event number (EN) |
|
69 * +-----------------------+ |
|
70 * where; |
|
71 * |
|
72 * FI = File Id 0x474f4c45 = ELOG |
|
73 * CL = Current free position in file (=offset value) |
|
74 * WO = Wrapping offset |
|
75 * EN = Event number; events are numbered starting from 1 |
|
76 * Number of the last event to be logged |
|
77 * |
|
78 * Log event data format: |
|
79 * |
|
80 * Log event data format: |
|
81 * 0 3 7 15 19 |
|
82 * +-----------+----------+------------+------------------+----------------+ |
|
83 * ! Length(L) ! Event ! TimeStamp) ! Source ! Catogory (EC)) ! |
|
84 * ! ! number(EN) (TS) ! Component (SC) ! |
|
85 * +-----------+----------+------------+------------------+----------------+ - - - - + |
|
86 * 23 27 31 n n+12 |
|
87 * +-----------+----------+------------+------------------+ |
|
88 * ! MsgId ! Descriptor Descriptors! Trailer (TR) ! |
|
89 * ! (MI) ! count (DC) (DE) ! ! |
|
90 * +-----------+----------+------------+------------------+ |
|
91 * * where; |
|
92 * |
|
93 * L = Length of log element |
|
94 * EN = Event number |
|
95 * TS = Time stamp (TTime in TInt64 (two TUint32) |
|
96 * SC = UID of source component |
|
97 * EC = Event catogory (Info, warning, error, debug) |
|
98 * MI = Message Id, defines a text string in localisation file |
|
99 * DC = Descriptor count, number of lth-data pairs |
|
100 * DE = Descriptors: lth,lth...,data,data,... These are used to modify |
|
101 * the text avaibale in localisation file |
|
102 * TR = Element trailer: endmark1, endmark2, length of log element |
|
103 * same value as in (L) |
|
104 * |
|
105 *---------------------------------------------------------------------*/ |
|
106 if ( OpenLogFile() ) |
|
107 { |
|
108 file_hdr.SetLength(EVENTLOG_FILE_HEADER_LTH); |
|
109 if ( GetFileHeader(file_hdr) ) { |
|
110 position = GetElemDataPosition(file_hdr, aEvent.Length()); |
|
111 if ( position ) { |
|
112 log_elem_lth = WriteLogElem(position, aEvent); |
|
113 if ( log_elem_lth ) { |
|
114 position += log_elem_lth; |
|
115 SaveFileHeader(position, file_hdr); |
|
116 } |
|
117 } |
|
118 } |
|
119 |
|
120 CloseLogFile(); |
|
121 } |
|
122 |
|
123 } |
|
124 |
|
125 TBool CEventLogger::OpenLogFile() |
|
126 { |
|
127 TBool file_created = EFalse; |
|
128 TInt position = 0; |
|
129 /*-------------------------------------------------------- |
|
130 * Open event log file |
|
131 *--------------------------------------------------------*/ |
|
132 if(iFS.Connect()!=KErrNone) |
|
133 return EFalse; |
|
134 if ( iLogFile.Create(iFS, iServer->EventLogFileName(), EFileWrite|EFileShareAny) != KErrNone ) |
|
135 { |
|
136 if (iLogFile.Open(iFS, iServer->EventLogFileName(), EFileWrite|EFileShareAny) != KErrNone) |
|
137 { |
|
138 // DEB(iEngine->PrintText(_L("Error opening Trace file\n"));) |
|
139 iFS.Close(); |
|
140 return EFalse; |
|
141 } |
|
142 } |
|
143 else file_created = ETrue; |
|
144 |
|
145 if ( file_created ) { |
|
146 /*-------------------------------------------------------- |
|
147 * Write file header initial values to created file |
|
148 * (Current_offset = First_elem_offset = 16) |
|
149 *--------------------------------------------------------*/ |
|
150 TBuf8<EVENTLOG_FILE_HEADER_LTH> file_hdr; |
|
151 file_hdr.SetLength(EVENTLOG_FILE_HEADER_LTH); |
|
152 StoreFileHeaderInfo(EVENTLOG_FILE_HEADER_LTH, 0, file_hdr); |
|
153 if ( SaveFileHeader(EVENTLOG_FILE_HEADER_LTH, file_hdr) == EFalse ) { |
|
154 // DEB(iEngine->PrintText(_L("File header creation error\n"));) |
|
155 return EFalse; |
|
156 } |
|
157 iLogFile.Seek(ESeekStart, position); // return file pointer to file start |
|
158 } |
|
159 |
|
160 return ETrue; |
|
161 } |
|
162 |
|
163 void CEventLogger::CloseLogFile() |
|
164 { |
|
165 /*-------------------------------------------------------- |
|
166 * Close event log file |
|
167 *--------------------------------------------------------*/ |
|
168 iLogFile.Close(); |
|
169 iFS.Close(); |
|
170 } |
|
171 |
|
172 TBool CEventLogger::GetFileHeader(TDes8 &aBuf) |
|
173 { |
|
174 /*-------------------------------------------------------- |
|
175 * Read current log file length from file start |
|
176 *--------------------------------------------------------*/ |
|
177 if ( iLogFile.Read(aBuf, EVENTLOG_FILE_HEADER_LTH) ) { |
|
178 return EFalse; |
|
179 } |
|
180 |
|
181 return ETrue; |
|
182 } |
|
183 |
|
184 |
|
185 TInt CEventLogger::GetElemDataPosition(TDes8 &aFileHdr, TInt aLength) |
|
186 { |
|
187 TInt position; |
|
188 /*--------------------------------------------------------------- |
|
189 * Get log element position value from file header |
|
190 * If (position + aLength) > file max length, wrap file |
|
191 *---------------------------------------------------------------*/ |
|
192 TFileHeader *file_hdr = (TFileHeader *)aFileHdr.Ptr(); |
|
193 position = file_hdr->GetPosition(); |
|
194 if ( ( position + aLength + |
|
195 ELEM_HEADER_LTH + ELEM_TRAILER_LTH ) > iFileMaxLength ) |
|
196 { |
|
197 position = EVENTLOG_FILE_HEADER_LTH; // Wrapping occurs |
|
198 } |
|
199 iEventNumber = file_hdr->GetEventNumber() + 1; |
|
200 |
|
201 return position; |
|
202 } |
|
203 |
|
204 /* |
|
205 TUint32 CEventLogger::GetTimeStamp() |
|
206 { |
|
207 TTime tmp_time; |
|
208 TDateTime date; |
|
209 TUint32 time_stamp = 0; |
|
210 */ |
|
211 /*--------------------------------------------------------------- |
|
212 * Get time stamp for log element. |
|
213 * Map the year-month-day-hour-minutes-seconds information to |
|
214 * 32 bits into the following way: |
|
215 * 3 2 1 0 |
|
216 * 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 |
|
217 * Y Y Y Y M M M M D D D D D D H H H H H H M M M M M M S S S S S S |
|
218 * where; |
|
219 * Bits 31-28 = Current Year - 2000 (0-15) |
|
220 * Bits 27-24 = Current Month index (0-11)) |
|
221 * Bits 23-18 = Current Day (1-31) |
|
222 * Bits 17-12 = Current Hour (0-23) |
|
223 * Bits 11-7 = Current Minutes (0-59) |
|
224 * Bits 6-0 = Current Seconds (0-59) |
|
225 * |
|
226 *--------------------------------------------------------------- / |
|
227 tmp_time.HomeTime(); |
|
228 date = tmp_time.DateTime(); |
|
229 |
|
230 time_stamp |= (((TUint32)(date.Year() - 2000)) << 28); |
|
231 time_stamp |= ((TUint32)date.Month() << 24); |
|
232 time_stamp |= ((TUint32)date.Day() << 18); |
|
233 time_stamp |= ((TUint32)date.Hour() << 12); |
|
234 time_stamp |= ((TUint32)date.Minute() << 6); |
|
235 time_stamp |= (TUint32)date.Second(); |
|
236 |
|
237 return time_stamp; |
|
238 } |
|
239 */ |
|
240 |
|
241 TBool CEventLogger::SaveFileHeader(TInt aPosition, TDes8 &aBuf) |
|
242 { |
|
243 TInt old_position; |
|
244 TInt wrapping_offset; |
|
245 /*--------------------------------------------------------------- |
|
246 * Save event log element position value to file header |
|
247 * If current position < position in file header, file has wrapped. |
|
248 * Store then wrapping offset in file header, too |
|
249 *---------------------------------------------------------------*/ |
|
250 TFileHeader *file_hdr = (TFileHeader *)aBuf.Ptr(); |
|
251 old_position = file_hdr->GetPosition(); |
|
252 wrapping_offset = file_hdr->GetWrappingOffset(); |
|
253 if ( old_position > aPosition ) { |
|
254 wrapping_offset = old_position; /* wrapping occurred */ |
|
255 } |
|
256 else { |
|
257 if ( wrapping_offset && ( wrapping_offset < aPosition ) ) { |
|
258 wrapping_offset = 0; |
|
259 } |
|
260 } |
|
261 |
|
262 StoreFileHeaderInfo(aPosition, wrapping_offset, aBuf); |
|
263 |
|
264 old_position = 0; // not old position really, just integer with value 0 needed |
|
265 iLogFile.Seek(ESeekStart, old_position); // return file pointer to file start |
|
266 if ( iLogFile.Write(aBuf, EVENTLOG_FILE_HEADER_LTH) ) |
|
267 return EFalse; |
|
268 |
|
269 return ETrue; |
|
270 } |
|
271 |
|
272 |
|
273 void CEventLogger::StoreFileHeaderInfo(TInt aPosition, TInt aWrappingOffset, TDes8 &aBuf) |
|
274 { |
|
275 |
|
276 TFileHeader *file_hdr = (TFileHeader *)aBuf.Ptr(); |
|
277 file_hdr->SetFileId(); |
|
278 file_hdr->SetPosition(aPosition); |
|
279 file_hdr->SetWrappingOffset(aWrappingOffset); |
|
280 file_hdr->SetEventNumber(iEventNumber); |
|
281 |
|
282 } |
|
283 |
|
284 TInt CEventLogger::WriteLogElem(TInt aPosition, const TDesC8& aEvent) |
|
285 |
|
286 //TInt CEventLogger::WriteLogElem(TInt aPosition, const TLogEvent& aEvent, const TDesC8& aData) |
|
287 { |
|
288 TBuf8<ELEM_HEADER_LTH> header; |
|
289 TBuf8<ELEM_TRAILER_LTH> trailer; |
|
290 // TUint32 time_stamp; |
|
291 TInt data_lth=aEvent.Length(); |
|
292 TInt eventLength = data_lth + ELEM_HEADER_LTH + ELEM_TRAILER_LTH; |
|
293 /*--------------------------------------------------------------- |
|
294 * Write log event data into the log file |
|
295 * Build first log element header: |
|
296 * log elem length + iEventNumber + time stamp |
|
297 *---------------------------------------------------------------*/ |
|
298 // time_stamp = GetTimeStamp(); |
|
299 header.SetLength(ELEM_HEADER_LTH); |
|
300 |
|
301 TElemHeader *elem_hdr = (TElemHeader *)header.Ptr(); |
|
302 elem_hdr->SetEventLength((TUint32) eventLength); |
|
303 elem_hdr->SetEventNumber((TUint32) iEventNumber); |
|
304 |
|
305 TTime tmpTime; |
|
306 const TInt64* currTime; |
|
307 tmpTime.HomeTime(); |
|
308 currTime = &tmpTime.Int64(); |
|
309 elem_hdr->SetTime(*currTime); |
|
310 |
|
311 trailer.SetLength(ELEM_TRAILER_LTH); |
|
312 TElemTrailer *elem_trailer = (TElemTrailer *)trailer.Ptr(); |
|
313 elem_trailer->SetLogEndMark(); |
|
314 elem_trailer->SetEventLength((TUint32) eventLength); |
|
315 iLogFile.Seek(ESeekStart, aPosition); // Set file pointer |
|
316 /*--------------------------------------------------------------- |
|
317 * Write log event into log element |
|
318 *---------------------------------------------------------------*/ |
|
319 if ( iLogFile.Write(header) ) //Element header |
|
320 return 0; |
|
321 |
|
322 if ( iLogFile.Write(aEvent)) //log event data |
|
323 return 0; |
|
324 |
|
325 if ( iLogFile.Write(trailer) ) //Element trailer |
|
326 return 0; |
|
327 |
|
328 return eventLength; |
|
329 |
|
330 } |
|
331 |