Imagelibrary/rtems
1
0
Fork 1
mirror of https://gitlab.rtems.org/rtems/rtos/rtems.git synced 2025-12-10 01:23:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Import from zlib-1.2.4

Browse Source
This commit is contained in:
Ralf Corsepius
2008-04-25 17:40:02 +00:00
parent 13d404a4eb
commit 21a750bb7e
1 changed files with 59 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
cpukit/zlib/examples/gzlog.h
View File

@@ -1,6 +1,6 @@
/* gzlog.h /* gzlog.h
Copyright (C) 2004 Mark Adler, all rights reserved Copyright (C) 2004, 2008 Mark Adler, all rights reserved
version 1.0, 26 Nov 2004 version 2.0, 25 Apr 2008
This software is provided 'as-is', without any express or implied This software is provided 'as-is', without any express or implied
warranty. In no event will the author be held liable for any damages warranty. In no event will the author be held liable for any damages
@@ -21,38 +21,69 @@
Mark Adler madler@alumni.caltech.edu Mark Adler madler@alumni.caltech.edu
*/ */
/* Version History:
1.0 26 Nov 2004 First version
2.0 25 Apr 2008 Complete redesign for recovery of interrupted operations
Interface changed slightly in that now path is a prefix
Compression now occurs as needed during gzlog_write()
gzlog_write() now always leaves the log file as valid gzip
*/
/* /*
The gzlog object allows writing short messages to a gzipped log file, The gzlog object allows writing short messages to a gzipped log file,
opening the log file locked for small bursts, and then closing it. The log opening the log file locked for small bursts, and then closing it. The log
object works by appending stored data to the gzip file until 1 MB has been object works by appending stored (uncompressed) data to the gzip file until
accumulated. At that time, the stored data is compressed, and replaces the 1 MB has been accumulated. At that time, the stored data is compressed, and
uncompressed data in the file. The log file is truncated to its new size at replaces the uncompressed data in the file. The log file is truncated to
that time. After closing, the log file is always valid gzip file that can its new size at that time. After each write operation, the log file is a
decompressed to recover what was written. valid gzip file that can decompressed to recover what was written.
A gzip header "extra" field contains two file offsets for appending. The The gzlog operations can be interupted at any point due to an application or
first points to just after the last compressed data. The second points to system crash, and the log file will be recovered the next time the log is
the last stored block in the deflate stream, which is empty. All of the opened with gzlog_open().
data between those pointers is uncompressed.
*/ */
#ifndef GZLOG_H
#define GZLOG_H
/* gzlog object type */
typedef void gzlog;
/* Open a gzlog object, creating the log file if it does not exist. Return /* Open a gzlog object, creating the log file if it does not exist. Return
NULL on error. Note that gzlog_open() could take a long time to return if NULL on error. Note that gzlog_open() could take a while to complete if it
there is difficulty in locking the file. */ has to wait to verify that a lock is stale (possibly for five minutes), or
void *gzlog_open(char *path); if there is significant contention with other instantiations of this object
when locking the resource. path is the prefix of the file names created by
this object. If path is "foo", then the log file will be "foo.gz", and
other auxiliary files will be created and destroyed during the process:
"foo.dict" for a compression dictionary, "foo.temp" for a temporary (next)
dictionary, "foo.add" for data being added or compressed, "foo.lock" for the
lock file, and "foo.repairs" to log recovery operations performed due to
interrupted gzlog operations. A gzlog_open() followed by a gzlog_close()
will recover a previously interrupted operation, if any. */
gzlog *gzlog_open(char *path);
/* Write to a gzlog object. Return non-zero on error. This function will /* Write to a gzlog object. Return zero on success, -1 if there is a file i/o
simply write data to the file uncompressed. Compression of the data error on any of the gzlog files (this should not happen if gzlog_open()
will not occur until gzlog_close() is called. It is expected that succeeded, unless the device has run out of space or leftover auxiliary
gzlog_write() is used for a short message, and then gzlog_close() is files have permissions or ownership that prevent their use), -2 if there is
called. If a large amount of data is to be written, then the application a memory allocation failure, or -3 if the log argument is invalid (e.g. if
should write no more than 1 MB at a time with gzlog_write() before it was not created by gzlog_open()). This function will write data to the
calling gzlog_close() and then gzlog_open() again. */ file uncompressed, until 1 MB has been accumulated, at which time that data
int gzlog_write(void *log, char *data, size_t len); will be compressed. The log file will be a valid gzip file upon successful
return. */
int gzlog_write(gzlog *log, void *data, size_t len);
/* Close a gzlog object. Return non-zero on error. The log file is locked /* Force compression of any uncompressed data in the log. This should be used
until this function is called. This function will compress stored data sparingly, if at all. The main application would be when a log file will
at the end of the gzip file if at least 1 MB has been accumulated. Note not be appended to again. If this is used to compress frequently while
that the file will not be a valid gzip file until this function completes. appending, it will both significantly increase the execution time and
*/ reduce the compression ratio. The return codes are the same as for
int gzlog_close(void *log); gzlog_write(). */
int gzlog_compress(gzlog *log);
/* Close a gzlog object. Return zero on success, -3 if the log argument is
invalid. The log object is freed, and so cannot be referenced again. */
int gzlog_close(gzlog *log);
#endif