diff options
Diffstat (limited to 'x11/konsole-kde4/files/patch-src_History.cpp')
| -rw-r--r-- | x11/konsole-kde4/files/patch-src_History.cpp | 214 |
1 files changed, 214 insertions, 0 deletions
diff --git a/x11/konsole-kde4/files/patch-src_History.cpp b/x11/konsole-kde4/files/patch-src_History.cpp new file mode 100644 index 000000000000..bc11a945bf48 --- /dev/null +++ b/x11/konsole-kde4/files/patch-src_History.cpp @@ -0,0 +1,214 @@ +* Revamp the file-based "unlimited" scrollback code to remove limits +* caused by 32bit file offsets. Use Qt's I/O functions which are +* buffered and use 64bit offsets. Use Qt's map instead of direct mmap +* to ensure consistency. Prevent wrap-around of readWriteBalance. +* +--- src/History.cpp.orig 2014-11-01 04:17:02 UTC ++++ src/History.cpp +@@ -25,9 +25,6 @@ + #include <stdlib.h> + #include <stdio.h> + #include <sys/types.h> +-#include <sys/mman.h> +-#include <unistd.h> +-#include <errno.h> + + // KDE + #include <kde_file.h> +@@ -56,8 +53,7 @@ using namespace Konsole; + + // History File /////////////////////////////////////////// + HistoryFile::HistoryFile() +- : _fd(-1), +- _length(0), ++ : _length(0), + _fileMap(0), + _readWriteBalance(0) + { +@@ -66,7 +62,6 @@ HistoryFile::HistoryFile() + _tmpFile.setFileTemplate(tmpFormat); + if (_tmpFile.open()) { + _tmpFile.setAutoRemove(true); +- _fd = _tmpFile.handle(); + } + } + +@@ -83,23 +78,26 @@ void HistoryFile::map() + { + Q_ASSERT(_fileMap == 0); + +- _fileMap = (char*)mmap(0 , _length , PROT_READ , MAP_PRIVATE , _fd , 0); ++ if (_tmpFile.flush()) { ++ Q_ASSERT(_tmpFile.size() >= _length); ++ _fileMap = _tmpFile.map(0, _length); ++ } + + //if mmap'ing fails, fall back to the read-lseek combination +- if (_fileMap == MAP_FAILED) { ++ if (_fileMap == 0) { + _readWriteBalance = 0; +- _fileMap = 0; +- kWarning() << "mmap'ing history failed. errno = " << errno; ++ perror("HistoryFile::map failed"); + } + } + + void HistoryFile::unmap() + { +- int result = munmap(_fileMap , _length); +- Q_ASSERT(result == 0); +- Q_UNUSED(result); ++ Q_ASSERT(_fileMap != 0); + +- _fileMap = 0; ++ if (_tmpFile.unmap(_fileMap)) ++ _fileMap = 0; ++ ++ Q_ASSERT(_fileMap == 0); + } + + bool HistoryFile::isMapped() const +@@ -107,21 +105,21 @@ bool HistoryFile::isMapped() const + return (_fileMap != 0); + } + +-void HistoryFile::add(const unsigned char* buffer, int count) ++void HistoryFile::add(const char* buffer, qint64 count) + { + if (_fileMap) + unmap(); + +- _readWriteBalance++; ++ if (_readWriteBalance < INT_MAX) ++ _readWriteBalance++; + +- int rc = 0; ++ qint64 rc = 0; + +- rc = KDE_lseek(_fd, _length, SEEK_SET); +- if (rc < 0) { ++ if (!_tmpFile.seek(_length)) { + perror("HistoryFile::add.seek"); + return; + } +- rc = write(_fd, buffer, count); ++ rc = _tmpFile.write(buffer, count); + if (rc < 0) { + perror("HistoryFile::add.write"); + return; +@@ -129,30 +127,32 @@ void HistoryFile::add(const unsigned cha + _length += rc; + } + +-void HistoryFile::get(unsigned char* buffer, int size, int loc) ++void HistoryFile::get(char* buffer, qint64 size, qint64 loc) + { ++ if (loc < 0 || size < 0 || loc + size > _length) { ++ fprintf(stderr, "getHist(...,%lld,%lld): invalid args.\n", size, loc); ++ return; ++ } ++ + //count number of get() calls vs. number of add() calls. + //If there are many more get() calls compared with add() + //calls (decided by using MAP_THRESHOLD) then mmap the log + //file to improve performance. +- _readWriteBalance--; ++ if (_readWriteBalance > INT_MIN) ++ _readWriteBalance--; + if (!_fileMap && _readWriteBalance < MAP_THRESHOLD) + map(); + + if (_fileMap) { +- for (int i = 0; i < size; i++) +- buffer[i] = _fileMap[loc + i]; ++ memcpy(buffer, _fileMap + loc, size); + } else { +- int rc = 0; ++ qint64 rc = 0; + +- if (loc < 0 || size < 0 || loc + size > _length) +- fprintf(stderr, "getHist(...,%d,%d): invalid args.\n", size, loc); +- rc = KDE_lseek(_fd, loc, SEEK_SET); +- if (rc < 0) { ++ if (!_tmpFile.seek(loc)) { + perror("HistoryFile::get.seek"); + return; + } +- rc = read(_fd, buffer, size); ++ rc = _tmpFile.read(buffer, size); + if (rc < 0) { + perror("HistoryFile::get.read"); + return; +@@ -160,7 +160,7 @@ void HistoryFile::get(unsigned char* buf + } + } + +-int HistoryFile::len() const ++qint64 HistoryFile::len() const + { + return _length; + } +@@ -206,7 +206,7 @@ HistoryScrollFile::~HistoryScrollFile() + + int HistoryScrollFile::getLines() + { +- return _index.len() / sizeof(int); ++ return _index.len() / sizeof(qint64); + } + + int HistoryScrollFile::getLineLen(int lineno) +@@ -218,21 +218,18 @@ bool HistoryScrollFile::isWrappedLine(in + { + if (lineno >= 0 && lineno <= getLines()) { + unsigned char flag; +- _lineflags.get((unsigned char*)&flag, sizeof(unsigned char), (lineno)*sizeof(unsigned char)); ++ _lineflags.get((char*)&flag, sizeof(unsigned char), (lineno)*sizeof(unsigned char)); + return flag; + } + return false; + } + +-int HistoryScrollFile::startOfLine(int lineno) ++qint64 HistoryScrollFile::startOfLine(int lineno) + { + if (lineno <= 0) return 0; + if (lineno <= getLines()) { +- if (!_index.isMapped()) +- _index.map(); +- +- int res; +- _index.get((unsigned char*)&res, sizeof(int), (lineno - 1)*sizeof(int)); ++ qint64 res; ++ _index.get((char*)&res, sizeof(qint64), (lineno - 1)*sizeof(qint64)); + return res; + } + return _cells.len(); +@@ -240,23 +237,20 @@ int HistoryScrollFile::startOfLine(int l + + void HistoryScrollFile::getCells(int lineno, int colno, int count, Character res[]) + { +- _cells.get((unsigned char*)res, count * sizeof(Character), startOfLine(lineno) + colno * sizeof(Character)); ++ _cells.get((char*)res, count * sizeof(Character), startOfLine(lineno) + colno * sizeof(Character)); + } + + void HistoryScrollFile::addCells(const Character text[], int count) + { +- _cells.add((unsigned char*)text, count * sizeof(Character)); ++ _cells.add((char*)text, count * sizeof(Character)); + } + + void HistoryScrollFile::addLine(bool previousWrapped) + { +- if (_index.isMapped()) +- _index.unmap(); +- +- int locn = _cells.len(); +- _index.add((unsigned char*)&locn, sizeof(int)); ++ qint64 locn = _cells.len(); ++ _index.add((char*)&locn, sizeof(qint64)); + unsigned char flags = previousWrapped ? 0x01 : 0x00; +- _lineflags.add((unsigned char*)&flags, sizeof(unsigned char)); ++ _lineflags.add((char*)&flags, sizeof(unsigned char)); + } + + // History Scroll None ////////////////////////////////////// |