Initial import of htcd system 1.0

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

1 files changed, 302 insertions, 0 deletions

diff --git a/src/hdb/filemap.cc b/src/hdb/filemap.cc
new file mode 100644
index 0000000..b40644f
--- /dev/null
+++ b/src/hdb/filemap.cc
@@ -0,0 +1,302 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <hdb/filemap.h>
+#include <mt/split.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <new>
+using namespace std;
+
+const int PAGESIZE=getpagesize();
+const filemap::char32 HEADNAME="HDB/1.2\n";
+const filemap::char32 COMPNAME="lt";
+const mstring dev_tag="/dev/";
+
+const int TIMEOUT=20;
+
+///////////////////////////////////////////////////
+
+filemap::head_t::head_t()
+{
+  memcpy(ident,HEADNAME,sizeof(char32));
+  lock.set(0);
+  minor.set(0);
+  major.set(0);
+  fatal.set(0);
+  filesize.set(PAGESIZE);
+  filetop.set(sizeof(head_t));
+  tables.set(0);
+  index.set(0);
+  memcpy(compname,COMPNAME,sizeof(char32));
+  memset(tabs,0,maxtabs*sizeof(char32));
+  frame.set(sizeof(head_t));
+}
+
+filemap::head_t::head_t(const head_t* hd,int mem)
+{
+  memcpy(ident,HEADNAME,sizeof(char32));
+  lock.set(0);
+  minor.set(0);
+  major.set(0);
+  fatal.set(0);
+  filetop.set(sizeof(head_t)+mem);
+  filesize.set(PAGESIZE*int((filetop.get()+PAGESIZE)/PAGESIZE));
+  tables=hd->tables;
+  index=hd->index;
+  memcpy(compname,hd->compname,sizeof(char32));
+  memset(tabs,0,maxtabs*sizeof(char32));
+  for(int i=0;i<tables.get();i++)
+    memcpy(tabs[i],hd->tabs[i],sizeof(char32));
+  frame.set(sizeof(head_t));
+}
+
+void filemap::head_t::setcomp(int idx,const sref& s)
+{
+  index.set(idx);
+  s.copyto(compname,sizeof(char32));
+  fatal.add(1);
+}
+
+void filemap::head_t::set(int col,const sref& s)
+{
+  s.copyto(tabs[col],sizeof(char32));
+  fatal.add(1);
+}
+
+void filemap::head_t::insert(int col,const sref& s)
+{
+  for(int i=maxtabs-1;i>col;i--)
+    memcpy(tabs[i],tabs[i-1],sizeof(char32));
+  if(index.get()>=col&&index.get()<tables.get())
+    index.add(1);
+  s.copyto(tabs[col],sizeof(char32));
+  tables.add(1);
+  fatal.add(1);
+}
+
+void filemap::head_t::remove(int col)
+{
+  if(index.get()!=col) {
+    for(int i=col;i<maxtabs-1;i++)
+      memcpy(tabs[i],tabs[i+1],sizeof(char32));
+    if(index.get()>col) index.set(index.get()-1);
+    tables.add(-1);
+    fatal.add(1);
+  }
+}
+
+///////////////////////////////////////////////////////
+
+filemap::chunk_t::chunk_t(chunk_t* p,int fd,int wok,int off,int size)
+{
+  next=p;
+  end=(begin=off)+size;
+  map=(char*)mmap(0,size,PROT_READ|(wok?PROT_WRITE:0),MAP_SHARED,fd,off);
+  if(map==MAP_FAILED) { map=0; THROW("filemap: could not map chunk") }
+}
+
+filemap::chunk_t::~chunk_t()
+{
+  if(map) munmap(map,end-begin);
+}
+
+int filemap::chunk_t::fill(int off)
+{
+  if(own(off)) {
+    at(off)->mem.set(end-off);
+    at(off)->caps.set(0);
+    return end;
+  }
+  else return off;
+}
+
+void filemap::chunk_t::sync()
+{
+  msync(map,end-begin,MS_SYNC);
+}
+
+///////////////////////////////////////////////////////
+
+void filemap::remap()
+{
+  while(mem->end<hd->filesize.get()) {
+    mem=new chunk_t(mem,fd,wok,mem->end,mem->size()<<1);
+  }
+}
+
+filemap::rec_t* filemap::add(int n)
+{
+  int caps=sizeof(rec_t),dim=caps+n;
+  while(caps<dim) caps<<=1;
+  remap();
+  if(hd->filesize.get()<mem->end) {
+    ftruncate(fd,mem->end);
+    hd->filesize.set(mem->end);
+  }
+  while(hd->filetop.get()+caps>mem->end) {
+    hd->filetop.set(mem->fill(hd->filetop.get()));
+    mem=new chunk_t(mem,fd,wok,mem->end,mem->size()<<1);    
+    ftruncate(fd,mem->end);
+    hd->filesize.set(mem->end);
+  }
+  rec_t* rec=at(hd->filetop.get());
+  hd->filetop.add(caps);
+  rec->mem.set(caps);
+  rec->caps.set(n);  
+  return rec;
+}
+
+void filemap::rem(rec_t* rec)
+{
+  rec->caps.set(0);
+}
+
+///////////////////////////////////////////////////////
+
+filemap::filemap(filemap* p):
+  next(p),fd(-1),wok(0),refs(0),pathname(),hd(0),mem(0),nodelock(0)
+{
+  memset(&mutex,0,sizeof(mutex_t));
+}
+
+filemap::filemap(filemap* p,const mstring& path,int update,int prot):
+  next(p),fd(-1),wok(0),refs(0),pathname(),hd(0),mem(0),nodelock(0)
+{
+  memset(&mutex,0,sizeof(mutex_t));
+  open(path,update,prot);
+}
+
+filemap::~filemap()
+{
+  close();
+}
+  
+///////////////////////////////////////////////////////
+
+void filemap::open(const mstring& path,int update,int prot) throw(merror_t)
+{
+  close();
+  if(update) {
+    if(path.left(5)!=dev_tag) nodelock=new nodelock_t(path);
+    else nodelock=0;
+    wok=1;
+  }
+  else {
+    nodelock=0;
+    wok=0;
+  }
+  fd=::open(path.c_str(),wok?O_RDWR|O_CREAT:O_RDONLY,prot);
+  if(fd<0) THROW("filemap: could not open "<<path);
+  int fsize=lseek(fd,0,SEEK_END);
+  int mapsize=PAGESIZE*int((fsize+PAGESIZE)/PAGESIZE);
+  hd=(head_t*)(mem=new chunk_t(0,fd,wok,0,mapsize))->map;
+  if(fsize<sizeof(head_t)) {
+    if(wok) { ftruncate(fd,fsize=mapsize); new(hd) head_t(); }
+    else THROW("filemap: not a HDB file");
+  }
+  if(First(sref(hd->ident))!=First(sref(HEADNAME))) THROW("filemap: bad version");
+  remap();
+  if(fsize!=hd->filesize.get())
+    THROW("filemap: "<<path<<" has bad filesize - run hdbfix");
+  pathname=path;
+}
+
+void filemap::check() throw(merror_t)
+{
+  // Make a consistency test, but NEVER change filetop!!!
+  // Severe loss of data may occur if you do
+  // Use hdbfix in case the db seems corrupted
+  int p=recs(),ft=hd->filetop.get();
+  while(size(p)) {
+    rec_t* rec=at(p);
+    p+=rec->mem.get();
+  }
+  if(p<ft) THROW("filemap: "<<pathname<<" is corrupted - run hdbfix");
+  // OK, at least no data is missing. Usually p==ft,
+  // but since no locking is done here, another process
+  // may make changes that turn p>ft.
+}
+
+void filemap::save(const mstring& path,int prot) throw(merror_t)
+{
+  if(path==pathname) THROW("filemap: cannot overwrite current file");
+  int mfd=::open(path.c_str(),O_RDWR|O_CREAT|O_TRUNC,prot);
+  if(mfd<0) THROW("filemap: could not open "<<path<<" for writing");
+  int caps=0,p=recs();
+  while(size(p)) {
+    rec_t* rec=at(p);
+    if(rec->caps.get()) caps+=rec->mem.get();
+    p+=rec->mem.get();
+  }
+  head_t mhd(hd,caps);
+  ::write(mfd,&mhd,sizeof(head_t));
+  p=recs();
+  while(size(p)) {
+    rec_t* rec=at(p);
+    if(rec->caps.get()) ::write(mfd,rec,rec->mem.get());
+    p+=rec->mem.get();
+  }
+  ftruncate(mfd,mhd.filesize.get());
+  ::close(mfd);
+}
+
+void filemap::close()
+{
+  while(mem) { chunk_t* p=mem->next; delete mem; mem=p; }
+  hd=0;
+  wok=0;
+  refs=0;
+  if(fd>=0) { ::close(fd); fd=-1; }
+  delete nodelock; nodelock=0;
+  pathname.clear();
+}
+
+void filemap::sync()
+{
+  for(chunk_t* p=mem;p;p=p->next) p->sync();
+}
+
+///////////////////////////////////////////////////////
+
+void filemap::lock()
+{
+  if(hd) {
+    MLOCK(mutex);
+    if((volatile long&)hd->lock) {
+      time_t end=time(0)+TIMEOUT;
+      while((volatile long&)hd->lock&&time(0)<end); 
+    }
+    hd->lock.set(1);
+  }
+}
+
+void filemap::unlock()
+{
+  if(hd) hd->lock.set(0);
+}
+
+///////////////////////////////////////////////////////
+
+time_t filemap::Lastmod() const
+{
+  struct stat fs; fstat(fd,&fs); return fs.st_mtime;
+}
+