NVcontainer Class Reference

#include <NVcontainer.h>

Inheritance diagram for NVcontainer:

List of all members.

Public Types
enum	{ UnLock = F_UNLCK, ShrdLock = F_RDLCK, ExclLock = F_WRLCK }
enum	{ Block = 0x0, NoBlock = 0x1 }
Public Member Functions
int	lock (int command, int block=Block)
int	get_lock (void)
virtual void	open (const char *dbname, int flags=0)
virtual int	is_open (void)
virtual void	close (void)
void	setmtime (nvtime_t tm, int force=0)
void	getmtime (nvtime_t *tm)
Protected Member Functions
	NVcontainer (void)
	NVcontainer (const char *dbname, int flags=0)
virtual	~NVcontainer (void)
virtual void	make_current (void)
virtual int	is_current (void)
virtual size_t	resize (size_t nsz)
nvoff_t	getdata ()
nvoff_t	getdatap ()
void	setdata (nvoff_t d)
nvoff_t	nvalloc (size_t rsz)
void	nvfree (nvoff_t f)
Protected Attributes
char *	mem_p
size_t	mem_sz
Private Member Functions
FreeList *	o2fl (nvoff_t o)
nvoff_t	fl2o (FreeList *r)
Private Attributes
int	lck_stack [NVcontainer_LOCKSTACKSIZE]
int	lck_stackp
char	mem_fn [MAXPATHLEN]
int	mem_fd
Header *	mem_hdr

---

Detailed Description

Author:

Thomas Gschwind How should we define a uniform interface to access data stored within an NVcontainer? Two kinds of accesses exist: shared access ... uses NVcontainer's data copy copy access ... copies the data at each request The second version is easier to use, but reduces the performance.

Bug:

Documentation is missing.

Definition at line 29 of file NVcontainer.h.

---

Member Enumeration Documentation

anonymous enum

Enumeration values: UnLock  ShrdLock  ExclLock  Definition at line 87 of file NVcontainer.h. { UnLock = F_UNLCK, ShrdLock = F_RDLCK, ExclLock = F_WRLCK };

anonymous enum

Enumeration values: Block  NoBlock  Definition at line 92 of file NVcontainer.h. { Block = 0x0, NoBlock = 0x1 };

---

Constructor & Destructor Documentation

NVcontainer::NVcontainer (  void   )  [protected]

Definition at line 96 of file NVcontainer.cc. References lck_stackp, mem_fd, mem_fn, mem_hdr, mem_p, and NVcontainer_LOCKSTACKSIZE. { lck_stackp = NVcontainer_LOCKSTACKSIZE; mem_fn[0] = '\0'; mem_fd = -1; mem_p = NULL; mem_hdr = (Header *) mem_p; }

NVcontainer::NVcontainer (  const char *  dbname, int  flags = 0 )  [protected]

Definition at line 105 of file NVcontainer.cc. References lck_stackp, mem_fd, NVcontainer_LOCKSTACKSIZE, and open(). { lck_stackp = NVcontainer_LOCKSTACKSIZE; mem_fd = -1; open(dbname, flags); }

NVcontainer::~NVcontainer (  void   )  [protected, virtual]

Definition at line 112 of file NVcontainer.cc. References close(). { close(); }

---

Member Function Documentation

void NVcontainer::close (  void   )  [virtual]

Reimplemented in NVActiveDB. Definition at line 637 of file NVcontainer.cc. References lck_stackp, mem_fd, mem_fn, mem_hdr, mem_p, mem_sz, NVcontainer_LOCKSTACKSIZE, slog, and VERB. Referenced by NVActiveDB::close(), make_current(), nvfree(), open(), and ~NVcontainer(). { if (mem_fd < 0) return; munmap(mem_p, mem_sz); ::close(mem_fd); if (lck_stackp != NVcontainer_LOCKSTACKSIZE) { VERB(slog. p(Logger:: Critical) << "NVcontainer::close: Forgot to unlock the container before closing it!\n"); lck_stackp = NVcontainer_LOCKSTACKSIZE; } mem_fn[0] = '\0'; mem_fd = -1; mem_p = NULL; mem_hdr = (Header *) mem_p; }

nvoff_t NVcontainer::fl2o (  FreeList *  r  )  [inline, private]

Definition at line 62 of file NVcontainer.h. References mem_p, and nvoff_t. Referenced by nvalloc(), and nvfree(). { return r ? (char *) r - mem_p : 0; }

int NVcontainer::get_lock (  void   )

Reimplemented in NVActiveDB. Definition at line 557 of file NVcontainer.cc. References lck_stack, lck_stackp, NVcontainer_LOCKSTACKSIZE, and UnLock. Referenced by NVActiveDB::get_lock(). { return lck_stackp < NVcontainer_LOCKSTACKSIZE ? lck_stack[lck_stackp] : UnLock; }

nvoff_t NVcontainer::getdata (   )  [protected]

Definition at line 188 of file NVcontainer.cc. References mem_hdr, nvoff_t, and NVcontainer::Header::userdata. Referenced by NVListIter::attach(), NVHash::make_current(), NVArray::make_current(), NVList::remove(), and NVArray::ssetsize(). { return mem_hdr->userdata; }

nvoff_t NVcontainer::getdatap (   )  [protected]

Definition at line 193 of file NVcontainer.cc. References mem_hdr, mem_p, nvoff_t, and NVcontainer::Header::userdata. Referenced by NVList::append(), NVList::clear(), NVList::is_empty(), NVList::prepend(), NVList::print(), and NVList::remove(). { return ((char *) &mem_hdr->userdata - mem_p); }

void NVcontainer::getmtime (  nvtime_t *  tm  )

Definition at line 665 of file NVcontainer.cc. References lock(), mem_hdr, NVcontainer::Header::mtime, nvtime_t, ShrdLock, and UnLock. Referenced by NVActiveDB::getmtime(), and CNewsgroup::updateOverview(). { lock(ShrdLock); (*tm) = mem_hdr->mtime; lock(UnLock); }

virtual int NVcontainer::is_current (  void   )  [inline, protected, virtual]

Definition at line 75 of file NVcontainer.h. References mem_hdr, mem_sz, and NVcontainer::Header::size. Referenced by NVHash::make_current(), make_current(), and NVArray::make_current(). { return mem_sz == mem_hdr->size; }

int NVcontainer::is_open (  void   )  [virtual]

Reimplemented in NVActiveDB. Definition at line 632 of file NVcontainer.cc. References mem_fd. Referenced by NVActiveDB::is_open(). { return mem_fd >= 0; }

int NVcontainer::lock (  int  command, int  block = Block )

Reimplemented in NVActiveDB. Definition at line 504 of file NVcontainer.cc. References ERROR_LOCATION, ExclLock, lck_stack, lck_stackp, make_current(), mem_fd, NoBlock, NVcontainer_LOCKSTACKSIZE, nvflock(), and UnLock. Referenced by NVHash::add(), NVList::append(), NVListIter::attach(), NVHashIter::attach(), NVList::clear(), NVHash::clear(), NVArray::clear(), NVArray::del(), NVListIter::detach(), NVHashIter::detach(), NVArray::get(), NVNewsgroup::getarticle(), getmtime(), NVNewsgroup::getover(), NVArray::has_element(), NVList::is_empty(), NVHash::is_empty(), NVArray::is_empty(), NVActiveDB::lock(), nvalloc(), nvfree(), NVHash::open(), CNewsgroup::prefetchGroup(), CNewsgroup::prefetchOverview(), NVList::prepend(), NVList::print(), NVHash::print(), NVArray::print(), NVNewsgroup::printarticle(), NVNewsgroup::printheaderdb(), NVNewsgroup::printlistgroup(), NVNewsgroup::printover(), NVNewsgroup::printoverdb(), NVNewsgroup::readoverdb(), NVList::remove(), resize(), NVArray::set(), NVNewsgroup::setarticle(), setmtime(), NVNewsgroup::setover(), NVNewsgroup::setsize(), NVArray::setsize(), CNewsgroup::setsize(), and CNewsgroup::updateOverview(). { int res; int curLock = UnLock; if (lck_stackp < NVcontainer_LOCKSTACKSIZE) { curLock = lck_stack[lck_stackp]; } if (command == UnLock) { // Unlock container if (lck_stackp >= NVcontainer_LOCKSTACKSIZE) { throw Error ("NVContainer(14364): Lock Stack underflow", ERROR_LOCATION); } lck_stackp++; command = lck_stackp < NVcontainer_LOCKSTACKSIZE ? lck_stack[lck_stackp] : UnLock; } else { // Lock container if (lck_stackp == 0) { throw Error ("NVContainer(24929): Lock Stack overflow", ERROR_LOCATION); } // Is already locked with excl => new lock must be excl if (curLock == ExclLock) command = ExclLock; lck_stack[--lck_stackp] = command; } // Relock if lock state changed if (curLock != command) { if ((res = nvflock(mem_fd, command, block)) < 0) { if (errno == EWOULDBLOCK && block == NoBlock) { lck_stackp++; return -1; } throw SystemError("NVContainer(8402): flock failed", errno, ERROR_LOCATION); } // Adapt to the new size if somebody changed the container's // size if (command != UnLock) make_current(); } return 0; }

void NVcontainer::make_current (  void   )  [protected, virtual]

Reimplemented in NVArray, and NVHash. Definition at line 117 of file NVcontainer.cc. References close(), ERROR_LOCATION, NVcontainer::Header::hlen, is_current(), mem_fd, mem_hdr, mem_p, mem_sz, nvoff_t, NVcontainer::Header::size, slog, VERB, and NVcontainer::Header::version. Referenced by lock(), NVHash::make_current(), NVArray::make_current(), open(), and resize(). { struct stat st; if (mem_p) { if (is_current()) return; munmap(mem_p, mem_sz); } if (fstat(mem_fd, &st) < 0) { throw SystemError("NVContainer(20801): fstat failed", errno, ERROR_LOCATION); } if ((nvoff_t) st.st_size <= (nvoff_t) sizeof(Header) + (nvoff_t) sizeof(FreeList)) { throw Error("NVConatiner(19603): info-record shrunk", ERROR_LOCATION); } mem_sz = st.st_size; mem_p = (char *) mmap(NULL, mem_sz, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, 0); if (mem_p == (char *) -1) { mem_p = NULL; throw SystemError("NVContainer(13784): mmap failed", errno, ERROR_LOCATION); } mem_hdr = (Header *) mem_p; //Do some sanity checks on the database if (mem_hdr->hlen != sizeof(Header) || mem_hdr->version != 2) { close(); throw Error("NVContainer(28196): no nvcontainer", ERROR_LOCATION); } if (mem_sz != mem_hdr->size) { VERB(slog. p(Logger:: Critical) << "NVcontainer: wrong database size stored in db-header - may be a hazard\n"); } }

nvoff_t NVcontainer::nvalloc (  size_t  rsz  )  [protected]

Definition at line 203 of file NVcontainer.cc. References ASSERT, NVcontainer::Header::bytes_free, ERROR_LOCATION, ExclLock, fl2o(), NVcontainer::Header::freelist, lock(), mem_hdr, mem_p, mem_sz, NVcontainer::FreeList::next, nvoff_t, o2fl(), Logger::p(), resize(), NVcontainer::FreeList::size, slog, UnLock, and VERB. Referenced by NVHash::open(), NVlist::sappend(), NVNewsgroup::setarticle(), NVNewsgroup::setover(), NVlist::sprepend(), NVArray::sset(), and NVArray::ssetsize(). { lock(ExclLock); FreeList *flhead = o2fl(mem_hdr->freelist); FreeList *cur, *prv, *res; // The allocated memory block has to meet several requirements // * aligned on 16 Byte boundary // * size has to be a multiple of 16 (simplifies the alignment) // * the allocated block has to hold its size // the memory after the size indicator will be returned rsz = (rsz + sizeof(unsigned long) + 0xf) & (~0xf); if (flhead == NULL) { throw Error ("NVContainer(5946): Database file corrupted (freelist==NULL)", ERROR_LOCATION); } // flhead points to the last free memory block available in the database prv = flhead; cur = o2fl(prv->next); // find the first suitable memory block in the database while (cur->size < rsz && cur != flhead) { prv = cur; cur = o2fl(cur->next); } if (cur == flhead) { // Special care has to be taken for the last free memory block // It must always be present! So we have to resize it, if its // memory is smaller than the requested size plus the size // necessary to maintain the last block of free memory. if (flhead->size < rsz + sizeof(FreeList)) { nvoff_t prvoff = fl2o(prv); // Since it is very likely that the mapped region will change // during the resize operation, we will have to save the // currently used pointers int needsz = rsz + sizeof(FreeList) - flhead->size; resize(mem_sz + needsz); cur = flhead = o2fl(mem_hdr->freelist); prv = o2fl(prvoff); ASSERT(if (cur->size < rsz + sizeof(FreeList)) { throw AssertionError ("NVContainer::nvalloc: resize failed", ERROR_LOCATION);} ); } } ASSERT(if (cur->size < rsz) { throw AssertionError ("NVContainer::nvalloc: did not find a large enough free memory block", ERROR_LOCATION);} ); res = cur; if (cur->size < rsz + sizeof(FreeList)) { // The available space is too small to split? // This may only occur if cur _is_not_ the tail of the free blocks ASSERT(if (res == flhead) { throw AssertionError ("NVContainer::nvalloc: Cannot split block of free memory at tail of database", ERROR_LOCATION);} ); prv->next = cur->next; rsz = cur->size; } else { // Split the space into two parts cur = (FreeList *) ((char *) cur + rsz); cur->size = res->size - rsz; if (prv != res) { // list contains at least two blocks cur->next = res->next; prv->next = fl2o(cur); if (res == flhead) { mem_hdr->freelist = fl2o(cur); } } else { // list contains only one block pointing to itself // this must be the free memory block at the tail ASSERT(if (res != flhead) { throw AssertionError ("NVList::nvalloc: Lost block of free memory at tail of database", ERROR_LOCATION);} ); mem_hdr->freelist = cur->next = fl2o(cur); } } mem_hdr->bytes_free -= rsz; lock(UnLock); *(unsigned long *) res = rsz; #ifdef FREELIST_ASSERT_ON char buf[256]; int i = 10000; prv = flhead = o2fl(mem_hdr->freelist);; cur = o2fl(prv->next); VERB(sprintf (buf, "nvalloc: checking freelist flhead=%p\n", flhead); slog.p(Logger::Debug) << buf); while (cur != flhead && i) { VERB(sprintf (buf, "nvalloc: elem(%lu)={%lu,%lu}\n", (nvoff_t) ((char *) cur - mem_p), cur->next, cur->size); slog.p(Logger::Debug) << buf); prv = cur; cur = o2fl(cur->next); ASSERT(if (prv >= cur) { throw AssertionError ("NVContainer::nvalloc: freelist out of order!", ERROR_LOCATION);} ); i--; } VERB(sprintf (buf, "nvfree: tail(%lu)={%lu,%lu}\n", (nvoff_t) ((char *) cur - mem_p), cur->next, cur->size); slog.p(Logger::Debug) << buf); if (!i) VERB(slog. p(Logger:: Debug) << "nvalloc: more than 10000 free blocks!\n"); #endif return (nvoff_t) ((char *) res - mem_p) + sizeof(unsigned long); }

void NVcontainer::nvfree (  nvoff_t  f  )  [protected]

Definition at line 336 of file NVcontainer.cc. References ASSERT, NVcontainer::Header::bytes_free, close(), ERROR_LOCATION, ExclLock, fl2o(), NVcontainer::Header::freelist, lock(), mem_hdr, mem_p, mem_sz, NVcontainer::FreeList::next, nvoff_t, o2fl(), Logger::p(), NVcontainer::FreeList::size, slog, UnLock, and VERB. Referenced by CNewsgroup::prefetchGroup(), NVArray::sclear(), NVArray::sdel(), NVNewsgroup::setarticle(), NVNewsgroup::setsize(), NVArray::setsize(), NVlist::sremove(), NVArray::sset(), NVArray::ssetsize(), and CNewsgroup::sUpdateOverview(). { #ifdef FREELIST_ASSERT_ON VERB(char buf[256]; sprintf(buf, "NVcontainer::nvfree(%lu)\n", p); slog.p(Logger::Debug) << buf); #endif lock(ExclLock); FreeList *pb, *pe; int psz; #ifdef FREELIST_ASSERT_ON FreeList *flhead; FreeList *cur, *prv; int i = 10000; prv = flhead = o2fl(mem_hdr->freelist);; cur = o2fl(prv->next); VERB(sprintf(buf, "nvfree: checking freelist flhead=%p\n", flhead); slog.p(Logger::Debug) << buf); while (cur != flhead && i) { VERB(sprintf (buf, "nvfree: elem(%lu)={%lu,%lu}\n", (nvoff_t) ((char *) cur - mem_p), cur->next, cur->size); slog.p(Logger::Debug) << buf); prv = cur; cur = o2fl(cur->next); ASSERT(if (prv >= cur) { throw AssertionError ("NVContainer::nvfree: freelist out of order!", ERROR_LOCATION);} ); i--; } VERB(sprintf (buf, "nvfree: tail(%lu)={%lu,%lu}\n", (nvoff_t) ((char *) cur - mem_p), cur->next, cur->size); slog.p(Logger::Debug) << buf); if (!i) VERB(slog. p(Logger:: Debug) << "nvfree: more than 10000 free blocks!\n"); #else FreeList *flhead = o2fl(mem_hdr->freelist); FreeList *cur = NULL, *prv = NULL; #endif pb = o2fl(p - sizeof(unsigned long)); psz = *(unsigned long *) pb; pe = (FreeList *) ((char *) pb + psz); // ASSERT(memset(pb,255,psz)); ASSERT(if ((char *) pb < mem_p || mem_p + mem_sz < (char *) pe) { char buf[1024]; close(); sprintf(buf, "NVcontainer::nvfree: tried to free illegal memory block ([%p,%p])!\nNVcontainer mapped from [%p,%p]", pb, pe, mem_p, mem_p + mem_sz); throw AssertionError(buf, ERROR_LOCATION);}); // flhead points to the last free memory block available in the database prv = flhead; cur = o2fl(prv->next); while (cur < pb && cur != flhead) { prv = cur; cur = o2fl(cur->next); ASSERT(if (prv >= cur) { throw AssertionError ("NVContainer::nvfree: freelist out of order!", ERROR_LOCATION);} ); } ASSERT(if (cur < pb) { char buf[1024]; close(); sprintf(buf, "NVcontainer::nvfree: tried to free unallocated memory block ([%p,%p])!\n Address must be smaller than flhead (%p)!\nNVcontainer mapped from[%p,%p]", pb, pe, flhead, mem_p, mem_p + mem_sz); throw AssertionError(buf, ERROR_LOCATION);}); if ((char *) prv + prv->size == (char *) pb) { #ifdef FREELIST_ASSERT_ON VERB(slog. p(Logger::Debug) << "nvfree: adjacent to previous\n"); #endif // The freed block is adjacent to the previous free block prv->size += psz; if (pe == cur) { #ifdef FREELIST_ASSERT_ON VERB(slog. p(Logger:: Debug) << "nvfree: adjacent to next---cool\n"); #endif // The freed block is adjacent to the next free block too, cool :) if (cur == flhead) mem_hdr->freelist = fl2o(prv); prv->size += cur->size; prv->next = cur->next; } } else if (pe == cur) { #ifdef FREELIST_ASSERT_ON VERB(slog. p(Logger::Debug) << "nvfree: adjacent to next\n"); #endif // The freed block is adjacent to the next free block if (cur->next == fl2o(cur)) { // Only one block of free memory left ASSERT(if (flhead != cur) { throw AssertionError ("NVContainer::nvfree: flhead lost trailing block of free memory", ERROR_LOCATION);} ); mem_hdr->freelist = pb->next = fl2o(pb); pb->size = psz + cur->size; } else { pb->next = cur->next; pb->size = psz + cur->size; prv->next = fl2o(pb); if (cur == flhead) mem_hdr->freelist = fl2o(pb); } } else { VERB(slog.p(Logger::Debug) << "nvfree: not adjacent\n"); // The freed block neither is adjacent to the previous nor to the // next free block pb->next = fl2o(cur); pb->size = psz; prv->next = fl2o(pb); } mem_hdr->bytes_free += psz; #ifdef FREELIST_ASSERT_ON i = 10000; prv = flhead = o2fl(mem_hdr->freelist);; cur = o2fl(prv->next); VERB(sprintf(buf, "nvfree: checking freelist flhead=%p\n", flhead); slog.p(Logger::Debug) << buf); while (cur != flhead && i) { VERB(sprintf (buf, "nvfree: elem(%lu)={%lu,%lu}\n", (nvoff_t) ((char *) cur - mem_p), cur->next, cur->size); slog.p(Logger::Debug) << buf); prv = cur; cur = o2fl(cur->next); ASSERT(if (prv >= cur) { throw AssertionError ("NVContainer::nvfree: freelist out of order!", ERROR_LOCATION);} ); i--; } VERB(sprintf (buf, "nvfree: tail(%lu)={%lu,%lu}\n", (nvoff_t) ((char *) cur - mem_p), cur->next, cur->size); slog.p(Logger::Debug) << buf); if (!i) VERB(slog. p(Logger:: Debug) << "nvfree: more than 10000 free blocks!\n"); #endif lock(UnLock); }

FreeList* NVcontainer::o2fl (  nvoff_t  o  )  [inline, private]

Definition at line 59 of file NVcontainer.h. References mem_p. Referenced by nvalloc(), nvfree(), and resize(). { return (FreeList *) (o ? mem_p + o : NULL); }

void NVcontainer::open (  const char *  dbname, int  flags = 0 )  [virtual]

Definition at line 565 of file NVcontainer.cc. References ASSERT, Block, NVcontainer::Header::bytes_free, close(), ERROR_LOCATION, ExclLock, NVcontainer::Header::freelist, NVcontainer::Header::hlen, make_current(), mem_fd, mem_fn, NVcontainer::FreeList::next, nvflock(), NVcontainer::FreeList::size, NVcontainer::Header::size, and UnLock. Referenced by NVArray::NVArray(), NVcontainer(), NVNewsgroup::NVNewsgroup(), and NVHash::open(). { ASSERT(if (!dbname) throw AssertionError ("NVContainer(1a): open called with null-ointer\n", ERROR_LOCATION)); if (strcmp(mem_fn, dbname) == 0) return; if (mem_fd >= 0) close(); char errbuf[MAXPATHLEN + 256]; struct stat st; flags = 0; strcpy(mem_fn, dbname); if ((mem_fd =::open(mem_fn, O_RDWR | O_CREAT, 0644)) < 0) { sprintf(errbuf, "NVList(15485): Cannot open(%s,O_RDWR|O_CREAT)", dbname); throw SystemError(errbuf, errno, ERROR_LOCATION); } nvflock(mem_fd, ExclLock, Block); if (fstat(mem_fd, &st) < 0) { throw SystemError("NVContainer(16974): fstat failed", errno, ERROR_LOCATION); } if (st.st_size == 0) { Header hdr; FreeList fl; hdr.freelist = hdr.hlen; hdr.size = 0x10000; fl.next = hdr.freelist; fl.size = hdr.bytes_free = hdr.size - hdr.hlen; if (ftruncate(mem_fd, hdr.size) < 0) { unlink(mem_fn); throw SystemError ("NVContainer(13947): cannot create nvcontainer", errno, ERROR_LOCATION); } if (write(mem_fd, &hdr, sizeof(Header)) != sizeof(Header)) { unlink(mem_fn); throw SystemError ("NVContainer(13948): write(info-record) failed", errno, ERROR_LOCATION); } if (write(mem_fd, &fl, sizeof(FreeList)) != sizeof(FreeList)) { unlink(mem_fn); throw SystemError ("NVContainer(23367): write(free-record) failed", errno, ERROR_LOCATION); } } nvflock(mem_fd, UnLock, Block); //Sanity checks of an existing database will be done in make_current(); }

size_t NVcontainer::resize (  size_t  nsz  )  [protected, virtual]

Definition at line 162 of file NVcontainer.cc. References NVcontainer::Header::bytes_free, ERROR_LOCATION, ExclLock, NVcontainer::Header::freelist, lock(), make_current(), mem_fd, mem_hdr, mem_sz, o2fl(), NVcontainer::Header::size, NVcontainer::FreeList::size, slog, UnLock, and VERB. Referenced by nvalloc(). { if (nsz < mem_sz) { VERB(slog. p(Logger:: Warning) << "NVContainer: reduction of database size not supported, ignored\n"); return mem_sz; } lock(ExclLock); FreeList *flhead = o2fl(mem_hdr->freelist); nsz = (nsz + 0x10000) & (~0xffff); if (ftruncate(mem_fd, nsz) < 0) { throw SystemError("NVList(2756): ftruncate failed", errno, ERROR_LOCATION); } mem_hdr->bytes_free += nsz - mem_sz; flhead->size += nsz - mem_sz; mem_hdr->size = nsz; make_current(); lock(UnLock); return mem_sz; }

void NVcontainer::setdata (  nvoff_t  d  )  [protected]

Definition at line 198 of file NVcontainer.cc. References mem_hdr, nvoff_t, and NVcontainer::Header::userdata. Referenced by NVHash::open(), and NVArray::ssetsize(). { mem_hdr->userdata = d; }

void NVcontainer::setmtime (  nvtime_t  tm, int  force = 0 )

Definition at line 656 of file NVcontainer.cc. References ExclLock, lock(), mem_hdr, NVcontainer::Header::mtime, nvtime_t, and UnLock. Referenced by CNewsgroup::prefetchGroup(), NVNewsgroup::readoverdb(), NVActiveDB::setmtime(), CNewsgroup::setsize(), and CNewsgroup::sUpdateOverview(). { lock(ExclLock); unsigned long ctm = mem_hdr->mtime; if (force || tm > ctm) mem_hdr->mtime = tm; lock(UnLock); }

---

Member Data Documentation

int NVcontainer::lck_stack[NVcontainer_LOCKSTACKSIZE] [private]

Definition at line 52 of file NVcontainer.h. Referenced by get_lock(), and lock().

int NVcontainer::lck_stackp [private]

Definition at line 53 of file NVcontainer.h. Referenced by close(), get_lock(), lock(), and NVcontainer().

int NVcontainer::mem_fd [private]

Definition at line 56 of file NVcontainer.h. Referenced by close(), is_open(), lock(), make_current(), NVcontainer(), open(), and resize().

char NVcontainer::mem_fn[MAXPATHLEN] [private]

Definition at line 55 of file NVcontainer.h. Referenced by close(), NVcontainer(), and open().

Header* NVcontainer::mem_hdr [private]

Definition at line 57 of file NVcontainer.h. Referenced by close(), getdata(), getdatap(), getmtime(), is_current(), make_current(), nvalloc(), NVcontainer(), nvfree(), resize(), setdata(), and setmtime().

char* NVcontainer::mem_p [protected]

Definition at line 71 of file NVcontainer.h. Referenced by close(), NVListIter::data(), NVHashIter::data(), fl2o(), NVActiveDB_Iter::get(), getdatap(), make_current(), nvalloc(), NVcontainer(), nvfree(), and o2fl().

size_t NVcontainer::mem_sz [protected]

Definition at line 72 of file NVcontainer.h. Referenced by close(), is_current(), make_current(), nvalloc(), nvfree(), and resize().

---

The documentation for this class was generated from the following files:

• NVcontainer.h
• NVcontainer.cc

---