You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
508 lines
12 KiB
508 lines
12 KiB
/***************************************************************************
|
|
* Copyright (C) 2005 by Joris Guisson *
|
|
* joris.guisson@gmail.com *
|
|
* *
|
|
* 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 Street, Fifth Floor, Boston, MA 02110-1301, USA. *
|
|
***************************************************************************/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <tqfile.h>
|
|
#include <kio/netaccess.h>
|
|
#include <klocale.h>
|
|
#include <kfileitem.h>
|
|
#include <util/array.h>
|
|
#include <util/fileops.h>
|
|
#include <torrent/globals.h>
|
|
#include <interfaces/functions.h>
|
|
#include <kapplication.h>
|
|
#include <util/log.h>
|
|
#include <util/error.h>
|
|
#include "cachefile.h"
|
|
#include "preallocationthread.h"
|
|
#include "settings.h"
|
|
|
|
|
|
// Not all systems have an O_LARGEFILE - Solaris depending
|
|
// on command-line defines, FreeBSD never - so in those cases,
|
|
// make it a zero bitmask. As long as it's only OR'ed into
|
|
// open(2) flags, that's fine.
|
|
//
|
|
#ifndef O_LARGEFILE
|
|
#define O_LARGEFILE (0)
|
|
#endif
|
|
|
|
|
|
|
|
|
|
namespace bt
|
|
{
|
|
|
|
CacheFile::CacheFile() : fd(-1),max_size(0),file_size(0),mutex(true)
|
|
{
|
|
read_only = false;
|
|
}
|
|
|
|
|
|
CacheFile::~CacheFile()
|
|
{
|
|
if (fd != -1)
|
|
close();
|
|
}
|
|
|
|
void CacheFile::changePath(const TQString & npath)
|
|
{
|
|
path = npath;
|
|
}
|
|
|
|
void CacheFile::openFile(Mode mode)
|
|
{
|
|
int flags = O_LARGEFILE;
|
|
|
|
// by default allways try read write
|
|
fd = ::open(TQFile::encodeName(path),flags | O_RDWR);
|
|
if (fd < 0 && mode == READ)
|
|
{
|
|
// in case RDWR fails, try readonly if possible
|
|
fd = ::open(TQFile::encodeName(path),flags | O_RDONLY);
|
|
if (fd >= 0)
|
|
read_only = true;
|
|
}
|
|
|
|
if (fd < 0)
|
|
{
|
|
throw Error(i18n("Cannot open %1 : %2").arg(path).arg(strerror(errno)));
|
|
}
|
|
|
|
file_size = FileSize(fd);
|
|
}
|
|
|
|
void CacheFile::open(const TQString & path,Uint64 size)
|
|
{
|
|
TQMutexLocker lock(&mutex);
|
|
// only set the path and the max size, we only open the file when it is needed
|
|
this->path = path;
|
|
max_size = size;
|
|
}
|
|
|
|
void* CacheFile::map(MMappeable* thing,Uint64 off,Uint32 size,Mode mode)
|
|
{
|
|
TQMutexLocker lock(&mutex);
|
|
// reopen the file if necessary
|
|
if (fd == -1)
|
|
{
|
|
// Out() << "Reopening " << path << endl;
|
|
openFile(mode);
|
|
}
|
|
|
|
if (read_only && mode != READ)
|
|
{
|
|
throw Error(i18n("Cannot open %1 for writing : readonly filesystem").arg(path));
|
|
}
|
|
|
|
if (off + size > max_size)
|
|
{
|
|
Out() << "Warning : writing past the end of " << path << endl;
|
|
Out() << (off + size) << " " << max_size << endl;
|
|
return 0;
|
|
}
|
|
|
|
int mmap_flag = 0;
|
|
switch (mode)
|
|
{
|
|
case READ:
|
|
mmap_flag = PROT_READ;
|
|
break;
|
|
case WRITE:
|
|
mmap_flag = PROT_WRITE;
|
|
break;
|
|
case RW:
|
|
mmap_flag = PROT_READ|PROT_WRITE;
|
|
break;
|
|
}
|
|
|
|
if (off + size > file_size)
|
|
{
|
|
Uint64 to_write = (off + size) - file_size;
|
|
// Out() << "Growing file with " << to_write << " bytes" << endl;
|
|
growFile(to_write);
|
|
}
|
|
|
|
Uint32 page_size = sysconf(_SC_PAGESIZE);
|
|
if (off % page_size > 0)
|
|
{
|
|
// off is not a multiple of the page_size
|
|
// so we play around a bit
|
|
Uint32 diff = (off % page_size);
|
|
Uint64 noff = off - diff;
|
|
// Out() << "Offsetted mmap : " << diff << endl;
|
|
#if HAVE_MMAP64
|
|
char* ptr = (char*)mmap64(0, size + diff, mmap_flag, MAP_SHARED, fd, noff);
|
|
#else
|
|
char* ptr = (char*)mmap(0, size + diff, mmap_flag, MAP_SHARED, fd, noff);
|
|
#endif
|
|
if (ptr == MAP_FAILED)
|
|
{
|
|
Out() << "mmap failed : " << TQString(strerror(errno)) << endl;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
CacheFile::Entry e;
|
|
e.thing = thing;
|
|
e.offset = off;
|
|
e.diff = diff;
|
|
e.ptr = ptr;
|
|
e.size = size + diff;
|
|
e.mode = mode;
|
|
mappings.insert((void*)(ptr + diff),e);
|
|
return ptr + diff;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
#if HAVE_MMAP64
|
|
void* ptr = mmap64(0, size, mmap_flag, MAP_SHARED, fd, off);
|
|
#else
|
|
void* ptr = mmap(0, size, mmap_flag, MAP_SHARED, fd, off);
|
|
#endif
|
|
if (ptr == MAP_FAILED)
|
|
{
|
|
Out() << "mmap failed : " << TQString(strerror(errno)) << endl;
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
CacheFile::Entry e;
|
|
e.thing = thing;
|
|
e.offset = off;
|
|
e.ptr = ptr;
|
|
e.diff = 0;
|
|
e.size = size;
|
|
e.mode = mode;
|
|
mappings.insert(ptr,e);
|
|
return ptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CacheFile::growFile(Uint64 to_write)
|
|
{
|
|
// reopen the file if necessary
|
|
if (fd == -1)
|
|
{
|
|
// Out() << "Reopening " << path << endl;
|
|
openFile(RW);
|
|
}
|
|
|
|
if (read_only)
|
|
throw Error(i18n("Cannot open %1 for writing : readonly filesystem").arg(path));
|
|
|
|
// jump to the end of the file
|
|
SeekFile(fd,0,SEEK_END);
|
|
|
|
if (file_size + to_write > max_size)
|
|
{
|
|
Out() << "Warning : writing past the end of " << path << endl;
|
|
Out() << (file_size + to_write) << " " << max_size << endl;
|
|
}
|
|
|
|
Uint8 buf[1024];
|
|
memset(buf,0,1024);
|
|
Uint64 num = to_write;
|
|
// write data until to_write is 0
|
|
while (to_write > 0)
|
|
{
|
|
int nb = to_write > 1024 ? 1024 : to_write;
|
|
int ret = ::write(fd,buf,nb);
|
|
if (ret < 0)
|
|
throw Error(i18n("Cannot expand file %1 : %2").arg(path).arg(strerror(errno)));
|
|
else if (ret != nb)
|
|
throw Error(i18n("Cannot expand file %1 : incomplete write").arg(path));
|
|
to_write -= nb;
|
|
}
|
|
file_size += num;
|
|
//
|
|
// Out() << TQString("growing %1 = %2").arg(path).arg(kt::BytesToString(file_size)) << endl;
|
|
|
|
if (file_size != FileSize(fd))
|
|
{
|
|
// Out() << TQString("Homer Simpson %1 %2").arg(file_size).arg(sb.st_size) << endl;
|
|
fsync(fd);
|
|
if (file_size != FileSize(fd))
|
|
{
|
|
throw Error(i18n("Cannot expand file %1").arg(path));
|
|
}
|
|
}
|
|
}
|
|
|
|
void CacheFile::unmap(void* ptr,Uint32 size)
|
|
{
|
|
int ret = 0;
|
|
TQMutexLocker lock(&mutex);
|
|
// see if it wasn't an offsetted mapping
|
|
if (mappings.contains(ptr))
|
|
{
|
|
CacheFile::Entry & e = mappings[ptr];
|
|
#if HAVE_MUNMAP64
|
|
if (e.diff > 0)
|
|
ret = munmap64((char*)ptr - e.diff,e.size);
|
|
else
|
|
ret = munmap64(ptr,e.size);
|
|
#else
|
|
if (e.diff > 0)
|
|
ret = munmap((char*)ptr - e.diff,e.size);
|
|
else
|
|
ret = munmap(ptr,e.size);
|
|
#endif
|
|
mappings.erase(ptr);
|
|
// no mappings, close temporary
|
|
if (mappings.count() == 0)
|
|
closeTemporary();
|
|
}
|
|
else
|
|
{
|
|
#if HAVE_MUNMAP64
|
|
ret = munmap64(ptr,size);
|
|
#else
|
|
ret = munmap(ptr,size);
|
|
#endif
|
|
}
|
|
|
|
if (ret < 0)
|
|
{
|
|
Out(SYS_DIO|LOG_IMPORTANT) << TQString("Munmap failed with error %1 : %2").arg(errno).arg(strerror(errno)) << endl;
|
|
}
|
|
}
|
|
|
|
void CacheFile::close()
|
|
{
|
|
TQMutexLocker lock(&mutex);
|
|
|
|
if (fd == -1)
|
|
return;
|
|
|
|
TQMap<void*,Entry>::iterator i = mappings.begin();
|
|
while (i != mappings.end())
|
|
{
|
|
int ret = 0;
|
|
CacheFile::Entry & e = i.data();
|
|
#if HAVE_MUNMAP64
|
|
if (e.diff > 0)
|
|
ret = munmap64((char*)e.ptr - e.diff,e.size);
|
|
else
|
|
ret = munmap64(e.ptr,e.size);
|
|
#else
|
|
if (e.diff > 0)
|
|
ret = munmap((char*)e.ptr - e.diff,e.size);
|
|
else
|
|
ret = munmap(e.ptr,e.size);
|
|
#endif
|
|
e.thing->unmapped();
|
|
|
|
i++;
|
|
mappings.erase(e.ptr);
|
|
|
|
if (ret < 0)
|
|
{
|
|
Out(SYS_DIO|LOG_IMPORTANT) << TQString("Munmap failed with error %1 : %2").arg(errno).arg(strerror(errno)) << endl;
|
|
}
|
|
}
|
|
::close(fd);
|
|
fd = -1;
|
|
}
|
|
|
|
void CacheFile::read(Uint8* buf,Uint32 size,Uint64 off)
|
|
{
|
|
TQMutexLocker lock(&mutex);
|
|
bool close_again = false;
|
|
|
|
// reopen the file if necessary
|
|
if (fd == -1)
|
|
{
|
|
// Out() << "Reopening " << path << endl;
|
|
openFile(READ);
|
|
close_again = true;
|
|
}
|
|
|
|
if (off >= file_size || off >= max_size)
|
|
{
|
|
throw Error(i18n("Error : Reading past the end of the file %1").arg(path));
|
|
}
|
|
|
|
// jump to right position
|
|
SeekFile(fd,(Int64)off,SEEK_SET);
|
|
if ((Uint32)::read(fd,buf,size) != size)
|
|
{
|
|
if (close_again)
|
|
closeTemporary();
|
|
|
|
throw Error(i18n("Error reading from %1").arg(path));
|
|
}
|
|
|
|
if (close_again)
|
|
closeTemporary();
|
|
}
|
|
|
|
void CacheFile::write(const Uint8* buf,Uint32 size,Uint64 off)
|
|
{
|
|
TQMutexLocker lock(&mutex);
|
|
bool close_again = false;
|
|
|
|
// reopen the file if necessary
|
|
if (fd == -1)
|
|
{
|
|
// Out() << "Reopening " << path << endl;
|
|
openFile(RW);
|
|
close_again = true;
|
|
}
|
|
|
|
if (read_only)
|
|
throw Error(i18n("Cannot open %1 for writing : readonly filesystem").arg(path));
|
|
|
|
if (off + size > max_size)
|
|
{
|
|
Out() << "Warning : writing past the end of " << path << endl;
|
|
Out() << (off + size) << " " << max_size << endl;
|
|
}
|
|
|
|
if (file_size < off)
|
|
{
|
|
//Out() << TQString("Writing %1 bytes at %2").arg(size).arg(off) << endl;
|
|
growFile(off - file_size);
|
|
}
|
|
|
|
// jump to right position
|
|
SeekFile(fd,(Int64)off,SEEK_SET);
|
|
int ret = ::write(fd,buf,size);
|
|
if (close_again)
|
|
closeTemporary();
|
|
|
|
if (ret == -1)
|
|
throw Error(i18n("Error writing to %1 : %2").arg(path).arg(strerror(errno)));
|
|
else if ((Uint32)ret != size)
|
|
{
|
|
Out() << TQString("Incomplete write of %1 bytes, should be %2").arg(ret).arg(size) << endl;
|
|
throw Error(i18n("Error writing to %1").arg(path));
|
|
}
|
|
|
|
if (off + size > file_size)
|
|
file_size = off + size;
|
|
}
|
|
|
|
void CacheFile::closeTemporary()
|
|
{
|
|
if (fd == -1 || mappings.count() > 0)
|
|
return;
|
|
|
|
::close(fd);
|
|
fd = -1;
|
|
}
|
|
|
|
|
|
|
|
void CacheFile::preallocate(PreallocationThread* prealloc)
|
|
{
|
|
TQMutexLocker lock(&mutex);
|
|
|
|
if (FileSize(path) == max_size)
|
|
{
|
|
Out(SYS_GEN|LOG_NOTICE) << "File " << path << " already big enough" << endl;
|
|
return;
|
|
}
|
|
|
|
Out(SYS_GEN|LOG_NOTICE) << "Preallocating file " << path << " (" << max_size << " bytes)" << endl;
|
|
bool close_again = false;
|
|
if (fd == -1)
|
|
{
|
|
openFile(RW);
|
|
close_again = true;
|
|
}
|
|
|
|
if (read_only)
|
|
{
|
|
if (close_again)
|
|
closeTemporary();
|
|
|
|
throw Error(i18n("Cannot open %1 for writing : readonly filesystem").arg(path));
|
|
}
|
|
|
|
try
|
|
{
|
|
bool res = false;
|
|
|
|
#ifdef HAVE_XFS_XFS_H
|
|
if( (! res) && Settings::fullDiskPrealloc() && (Settings::fullDiskPreallocMethod() == 1) )
|
|
{
|
|
res = XfsPreallocate(fd, max_size);
|
|
}
|
|
#endif
|
|
|
|
if(! res)
|
|
{
|
|
bt::TruncateFile(fd,max_size,!Settings::fullDiskPrealloc());
|
|
}
|
|
}
|
|
catch (bt::Error & e)
|
|
{
|
|
// first attempt failed, must be fat so try that
|
|
if (!FatPreallocate(fd,max_size))
|
|
{
|
|
if (close_again)
|
|
closeTemporary();
|
|
|
|
throw Error(i18n("Cannot preallocate diskspace : %1").arg(strerror(errno)));
|
|
}
|
|
}
|
|
|
|
file_size = FileSize(fd);
|
|
Out(SYS_GEN|LOG_DEBUG) << "file_size = " << file_size << endl;
|
|
if (close_again)
|
|
closeTemporary();
|
|
}
|
|
|
|
Uint64 CacheFile::diskUsage()
|
|
{
|
|
Uint64 ret = 0;
|
|
bool close_again = false;
|
|
if (fd == -1)
|
|
{
|
|
openFile(READ);
|
|
close_again = true;
|
|
}
|
|
|
|
struct stat sb;
|
|
if (fstat(fd,&sb) == 0)
|
|
{
|
|
ret = (Uint64)sb.st_blocks * 512;
|
|
}
|
|
|
|
// Out(SYS_GEN|LOG_NOTICE) << "CF: " << path << " is taking up " << ret << " bytes" << endl;
|
|
if (close_again)
|
|
closeTemporary();
|
|
|
|
return ret;
|
|
}
|
|
}
|