![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to logfile.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / sys|
Return to logfile.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / sys |
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42: #include <sys/param.h>
43: #include <sys/stat.h>
44: #include <sys/mman.h>
45: #include <netinet/in.h>
46:
47: #include <stdio.h>
48: #include <stdlib.h>
49: #include <stdarg.h>
50: #include <syslog.h>
51: #include <unistd.h>
52: #include <errno.h>
53: #include <assert.h>
54: #include <string.h>
55: #include <pthread.h>
56: #include <fcntl.h>
57:
58: #include "structs/structs.h"
59: #include "structs/type/array.h"
60: #include "sys/logfile.h"
61: #include "sys/alog.h"
62: #include "util/typed_mem.h"
63:
64: #define LOGFILE_MEM_TYPE "logfile"
65: #define LOGFILE_MAGIC 0x476ea198
66:
67: #define MAX_ENTRIES (1 << 20)
68: #define MAX_DATA (1 << 24)
69:
70: /* Structure passed back to client */
71: struct logfile {
72: struct loghead *head; /* mmap'd file region */
73: pthread_mutex_t mutex; /* mutex lock */
74: u_int32_t headlen; /* length of head + entries */
75: int fd; /* file descriptor for file */
76: };
77:
78: struct logent {
79: u_int32_t offset;
80: u_int32_t length;
81: };
82:
83: /* Initial part of a log file; all fields in host order */
84: struct loghead {
85: u_int32_t magic; /* magic number */
86: u_int32_t maxent; /* max # entries */
87: u_int32_t maxdata; /* max data area length */
88: u_int32_t num; /* number of valid entries */
89: u_int32_t next; /* next entry index */
90: struct logent ents[0]; /* maxent entries */
91: };
92:
93: /*
94: * Open/create a new logfile.
95: */
96: struct logfile *
97: logfile_open(const char *path, int flags, u_int32_t maxent, u_int32_t maxdata)
98: {
99: struct logfile *lf;
100: struct loghead head;
101: int initialize;
102: int esave;
103:
104: /* Get and sanity check flags */
105: switch (flags) {
106: case 0:
107: #ifdef O_SHLOCK
108: case O_SHLOCK:
109: case O_EXLOCK:
110: #endif
111: break;
112: default:
113: errno = EINVAL;
114: return (NULL);
115: }
116: #ifdef O_SHLOCK
117: if ((flags & (O_SHLOCK|O_EXLOCK)) != 0)
118: flags |= O_NONBLOCK;
119: #endif
120:
121: /* Create object and open file */
122: if ((lf = MALLOC(LOGFILE_MEM_TYPE, sizeof(*lf))) == NULL)
123: return (NULL);
124: memset(lf, 0, sizeof(*lf));
125: if (path != NULL) {
126: if ((lf->fd = open(path, O_CREAT|O_RDWR|flags, 0644)) == -1)
127: goto fail;
128: (void)fcntl(lf->fd, F_SETFD, 1);
129: } else
130: lf->fd = -1;
131:
132: /* See if file already existed */
133: if (lf->fd != -1) {
134: struct stat sb;
135:
136: if (fstat(lf->fd, &sb) == -1)
137: goto fail;
138: if (!(initialize = (sb.st_size == 0))) {
139: int r;
140:
141: if ((r = read(lf->fd,
142: &head, sizeof(head))) != sizeof(head)) {
143: if (r != -1)
144: errno = EINVAL;
145: goto fail;
146: }
147: if (head.magic != LOGFILE_MAGIC) {
148: errno = EINVAL;
149: goto fail;
150: }
151: maxdata = head.maxdata;
152: maxent = head.maxent;
153: }
154: } else
155: initialize = 1;
156:
157: /* Sanity check parameters */
158: if (maxent == 0 || maxdata == 0
159: || maxent > MAX_ENTRIES || maxdata > MAX_DATA) {
160: errno = EINVAL;
161: goto fail;
162: }
163:
164: /* Compute size of header */
165: lf->headlen = sizeof(*lf->head) + (maxent * sizeof(*lf->head->ents));
166:
167: /* Set file length */
168: if (lf->fd != -1 && ftruncate(lf->fd, lf->headlen + maxdata) == -1)
169: goto fail;
170:
171: /* Memory map file */
172: if ((lf->head = mmap(NULL, lf->headlen + maxdata, PROT_READ|PROT_WRITE,
173: path == NULL ? MAP_ANON : MAP_SHARED, lf->fd, 0)) == MAP_FAILED)
174: goto fail;
175:
176: /* For new file, write header and initialize entries */
177: if (initialize) {
178: lf->head->magic = LOGFILE_MAGIC;
179: lf->head->maxdata = maxdata;
180: lf->head->maxent = maxent;
181: lf->head->num = 0;
182: lf->head->next = 0;
183: memset(lf->head->ents, 0, maxent * sizeof(*lf->head->ents));
184: (void)msync(lf->head, 0, MS_ASYNC);
185: }
186:
187: /* Sanitize header fields */
188: if (lf->head->num > lf->head->maxent)
189: lf->head->num = lf->head->maxent;
190: lf->head->next %= lf->head->maxent;
191:
192: /* Initialize mutex */
193: if ((errno = pthread_mutex_init(&lf->mutex, NULL)) != 0)
194: goto fail;
195:
196: /* Done */
197: return (lf);
198:
199: fail:
200: esave = errno;
201: if (lf->fd != -1)
202: (void)close(lf->fd);
203: if (lf->head != NULL)
204: (void)munmap(lf->head, lf->headlen + maxdata);
205: FREE(LOGFILE_MEM_TYPE, lf);
206: errno = esave;
207: return (NULL);
208: }
209:
210: /*
211: * Close a logfile.
212: */
213: void
214: logfile_close(struct logfile **lfp)
215: {
216: struct logfile *const lf = *lfp;
217:
218: /* Check for NULL */
219: if (lf == NULL)
220: return;
221: *lfp = NULL;
222:
223: /* Close up shop */
224: (void)msync(lf->head, 0, MS_SYNC);
225: (void)munmap(lf->head, lf->headlen + lf->head->maxdata);
226: if (lf->fd != -1)
227: (void)close(lf->fd);
228: pthread_mutex_destroy(&lf->mutex);
229: FREE(LOGFILE_MEM_TYPE, lf);
230: }
231:
232: /*
233: * Get the number of valid entries in a logfile.
234: */
235: u_int32_t
236: logfile_num_entries(struct logfile *lf)
237: {
238: u_int32_t num;
239: int r;
240:
241: r = pthread_mutex_lock(&lf->mutex);
242: assert(r == 0);
243: num = lf->head->num;
244: r = pthread_mutex_unlock(&lf->mutex);
245: assert(r == 0);
246: return (num);
247: }
248:
249: /*
250: * Trim the number of stored entries.
251: */
252: void
253: logfile_trim(struct logfile *lf, int num)
254: {
255: int r;
256:
257: r = pthread_mutex_lock(&lf->mutex);
258: assert(r == 0);
259: if (lf->head->num > num)
260: lf->head->num = num;
261: r = pthread_mutex_unlock(&lf->mutex);
262: assert(r == 0);
263: }
264:
265: /*
266: * Retrieve an entry.
267: */
268: const void *
269: logfile_get(struct logfile *lf, int which, int *lenp)
270: {
271: struct loghead *const head = lf->head;
272: struct logent *ent;
273: const void *rtn;
274: int r;
275:
276: /* Lock logfile */
277: r = pthread_mutex_lock(&lf->mutex);
278: assert(r == 0);
279:
280: /* Find entry */
281: if (which >= 0 || which < -head->num) {
282: r = pthread_mutex_unlock(&lf->mutex);
283: assert(r == 0);
284: errno = ENOENT;
285: return (NULL);
286: }
287: ent = &head->ents[(head->next + head->maxent + which) % head->maxent];
288:
289: /* Sanity check it */
290: if (ent->offset > head->maxdata
291: || ent->length > head->maxdata
292: || ent->offset + ent->length > head->maxdata) {
293: r = pthread_mutex_unlock(&lf->mutex);
294: assert(r == 0);
295: errno = EINVAL;
296: return (NULL);
297: }
298:
299: /* Get data and length */
300: if (lenp != NULL)
301: *lenp = ent->length;
302: rtn = (u_char *)lf->head + lf->headlen + ent->offset;
303:
304: /* Unlock logfile */
305: r = pthread_mutex_unlock(&lf->mutex);
306: assert(r == 0);
307:
308: /* Done */
309: return (rtn);
310: }
311:
312: /*
313: * Put an entry.
314: */
315: int
316: logfile_put(struct logfile *lf, const void *data, int len)
317: {
318: struct loghead *const head = lf->head;
319: struct logent *ent;
320: u_int32_t start;
321: int wrap = 0;
322: int r;
323:
324: if (len < 0) {
325: errno = EINVAL;
326: return (-1);
327: }
328: if (len > head->maxdata) {
329: errno = EMSGSIZE;
330: return (-1);
331: }
332:
333: /* Lock logfile */
334: r = pthread_mutex_lock(&lf->mutex);
335: assert(r == 0);
336:
337: /* Figure out where this entry's data will go */
338: if (head->num > 0) {
339: ent = &head->ents[(head->next
340: + head->maxent - 1) % head->maxent];
341: start = ALIGN(ent->offset + ent->length);
342: if (start + len > head->maxdata) { /* won't fit, wrap it */
343: wrap = start; /* point where we were forced to wrap */
344: start = 0;
345: }
346: } else {
347: head->next = 0;
348: start = 0;
349: }
350:
351: /* Remove all entries whose data overlaps the new guy's data */
352: for ( ; head->num > 0; head->num--) {
353: ent = &head->ents[(head->next
354: + head->maxent - head->num) % head->maxent];
355: if (wrap != 0) { /* clear out end region we skipped */
356: if (ent->offset >= wrap)
357: continue;
358: wrap = 0;
359: }
360: if (ent->offset + ent->length <= start
361: || ent->offset >= start + len)
362: break;
363: }
364:
365: /* Save entry */
366: ent = &head->ents[head->next];
367: ent->offset = start;
368: ent->length = len;
369: memcpy((u_char *)lf->head + lf->headlen + ent->offset, data, len);
370: if (head->num < head->maxent)
371: head->num++;
372: head->next = (head->next + 1) % head->maxent;
373:
374: /* Unlock logfile */
375: r = pthread_mutex_unlock(&lf->mutex);
376: assert(r == 0);
377:
378: /* Done */
379: return (0);
380: }
381:
382: /*
383: * Sync logfile to disk.
384: */
385: void
386: logfile_sync(struct logfile *lf)
387: {
388: int r;
389:
390: r = pthread_mutex_lock(&lf->mutex);
391: assert(r == 0);
392: (void)msync(lf->head, 0, MS_SYNC);
393: r = pthread_mutex_unlock(&lf->mutex);
394: assert(r == 0);
395: }
396:
397: #ifdef LOGFILE_TEST
398:
399: #include <err.h>
400:
401: int
402: main(int ac, char **av)
403: {
404: const time_t now = time(NULL);
405: struct logfile *lf;
406: int maxent = 0;
407: int maxdata = 0;
408: int readonly = 0;
409: int alog_ents = 0;
410: long seed = 0;
411: int num = -1;
412: char *path;
413: int i;
414: int ch;
415:
416: srandomdev();
417:
418: while ((ch = getopt(ac, av, "s:n:ra")) != -1) {
419: switch (ch) {
420: case 's':
421: seed = atol(optarg);
422: break;
423: case 'n':
424: num = atol(optarg);
425: break;
426: case 'a':
427: alog_ents = 1;
428: break;
429: case 'r':
430: readonly = 1;
431: break;
432: default:
433: goto usage;
434: }
435: }
436: ac -= optind;
437: av += optind;
438:
439: /* Sanity */
440: if (!readonly)
441: alog_ents = 0;
442:
443: if (!readonly && seed == 0) {
444: seed = random();
445: printf("Seed is %ld.\n", seed);
446: }
447: srandom(seed);
448:
449: switch (ac) {
450: case 3:
451: maxent = atoi(av[1]);
452: maxdata = atoi(av[2]);
453: /* fall through */
454: case 1:
455: path = av[0];
456: break;
457: default:
458: usage: fprintf(stderr, "usage: logfile [-r] [-s seed] [-n num]"
459: " path [maxent maxdata]\n");
460: exit(1);
461: }
462:
463: /* Open log */
464: if ((lf = logfile_open(strcmp(path, "-") == 0 ? NULL : path,
465: maxent, maxdata)) == NULL)
466: err(1, "%s", path);
467:
468: /* Read only? */
469: if (readonly)
470: goto readit;
471:
472: /* Write some entries into it */
473: printf("Logfile \"%s\" has %d entries.\n",
474: path, logfile_num_entries(lf));
475: if (num == -1)
476: num = random() % 64;
477: printf("Writing %d entries...\n", num);
478: for (i = 0; i < num; i++) {
479: char buf[128];
480: int nex;
481: int j;
482:
483: snprintf(buf, sizeof(buf), "%03ld:%03d ", now % 1000, i);
484: nex = random() % 32;
485: for (j = 0; j < nex; j++) {
486: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
487: "%02lx", random() % 0x100);
488: }
489: strlcat(buf, "\n", sizeof(buf));
490: if (logfile_put(lf, buf, strlen(buf) + 1) == -1)
491: warn("logfile_put: \"%s\"", buf);
492: }
493:
494: readit:
495: num = logfile_num_entries(lf);
496: printf("Logfile \"%s\" now has %d entries\n", path, num);
497: printf("\t maxent=%u\n", lf->head->maxent);
498: printf("\tmaxdata=%u\n", lf->head->maxdata);
499: printf("\t next=%u\n", lf->head->next);
500: for (i = -num; i < 0; i++) {
501: const void *e;
502: int len;
503:
504: printf("%4d: ", i + num);
505: if ((e = logfile_get(lf, i, &len)) == NULL) {
506: warn("logfile_get(%d)", i);
507: continue;
508: }
509: if (alog_ents) {
510: const struct alog_entry *const ent = e;
511: struct tm tm;
512: char tbuf[64];
513:
514: strftime(tbuf, sizeof(tbuf),
515: "%b %e %T", localtime_r(&ent->when, &tm));
516: printf("%s [%d] %s\n", tbuf, ent->sev, ent->msg);
517: } else
518: printf("(%2d) %s", len, (const char *)e);
519: }
520: printf("Closing logfile...\n");
521: logfile_close(&lf);
522: return (0);
523: }
524:
525: #endif /* LOGFILE_TEST */
526:
527: