void
PackageFSRoot::RemovePackage(Package* package)
{
PackageFSRootWriteLocker writeLocker(this);
_RemovePackage(package);
}
KisPaintDeviceSP KisMultipleProjection::getProjection(const QString &id, const QString &compositeOpId, KisPaintDeviceSP prototype)
{
QReadLocker readLocker(&m_d->lock);
PlanesMap::const_iterator constIt = m_d->planes.constFind(id);
if (constIt == m_d->planes.constEnd() ||
constIt->compositeOpId != compositeOpId ||
!(*constIt->device->colorSpace() == *prototype->colorSpace())) {
readLocker.unlock();
{
QWriteLocker writeLocker(&m_d->lock);
PlanesMap::iterator writeIt = m_d->planes.find(id);
if (writeIt == m_d->planes.end()) {
ProjectionStruct plane;
plane.device = new KisPaintDevice(*prototype);
plane.compositeOpId = compositeOpId;
writeIt = m_d->planes.insert(id, plane);
} else if (writeIt->compositeOpId != compositeOpId ||
!(*writeIt->device->colorSpace() == *prototype->colorSpace())) {
writeIt->device->makeCloneFromRough(prototype, prototype->extent());
writeIt->compositeOpId = compositeOpId;
}
return writeIt->device;
}
}
return constIt->device;
}
bool
object_depot_contains_object(object_depot* depot, void* object)
{
WriteLocker writeLocker(depot->outer_lock);
int cpuCount = smp_get_num_cpus();
for (int i = 0; i < cpuCount; i++) {
depot_cpu_store& store = depot->stores[i];
if (store.loaded != NULL && !store.loaded->IsEmpty()) {
if (store.loaded->ContainsObject(object))
return true;
}
if (store.previous != NULL && !store.previous->IsEmpty()) {
if (store.previous->ContainsObject(object))
return true;
}
}
for (DepotMagazine* magazine = depot->full; magazine != NULL;
magazine = magazine->next) {
if (magazine->ContainsObject(object))
return true;
}
return false;
}
void BasicKeywordsModel::setKeywords(const QStringList &keywordsList) {
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
setKeywordsUnsafe(keywordsList);
}
void PeerObject::readPackage()
{
// static int readCount = 0;
// m_dbgLog.write("PeerObject::readData()");
// m_dbgLog.write(QString("(%1)\n").arg(++readCount).toLatin1());
// m_dbgLog.flush();
static quint64 totalRead = 0;
QByteArray package(m_socket->read().toByteArray());
if(package.isEmpty()) {
qDebug("Peer: PeerObject::readPackage() - zero size data");
m_peerSocket->write(QStringLiteral("fReceived zero size").toLatin1());
// m_peerSocket->flush();
if(m_close)
close(1);
return;
}
QWriteLocker writeLocker(&m_dataPkgLock);
m_dataPkg.append(package);
static int totalReadPkgCount = 0;
totalReadPkgCount++;
Logger::log("Handled packages", totalReadPkgCount);
callSlotQueued(this, "checkReadData");
}
int BasicKeywordsModel::appendKeywords(const QStringList &keywordsList) {
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
return appendKeywordsUnsafe(keywordsList);
}
bool BasicKeywordsModel::appendKeyword(const QString &keyword) {
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
return appendKeywordUnsafe(keyword);
}
bool SvgHandler::loadSvg( const QString& name )
{
QString svgFilename;
if ( !m_customTheme )
svgFilename = KStandardDirs::locate( "data", name );
else
svgFilename = name;
KSvgRenderer *renderer = new KSvgRenderer( The::svgTinter()->tint( svgFilename ).toAscii() );
if ( !renderer->isValid() )
{
debug() << "Bluddy 'ell mateys, aye canna' load ya Ess Vee Gee at " << svgFilename;
delete renderer;
return false;
}
QWriteLocker writeLocker( &m_lock );
if( m_renderers[name] )
delete m_renderers[name];
m_renderers[name] = renderer;
return true;
}
void BasicKeywordsModel::setSpellCheckResults(const std::vector<std::shared_ptr<SpellCheck::SpellCheckQueryItem> > &items) {
LOG_DEBUG << items.size() << "results";
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
setSpellCheckResultsUnsafe(items);
}
bool BasicKeywordsModel::removeKeywords(const QSet<QString> &keywords, bool caseSensitive) {
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
bool result = removeKeywordsUnsafe(keywords, caseSensitive);
return result;
}
void BasicKeywordsModel::removeItemsAtIndices(const QVector<QPair<int, int> > &ranges) {
LOG_INFO << "#";
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
int rangesLength = Helpers::getRangesLength(ranges);
AbstractListModel::doRemoveItemsAtIndices(ranges, rangesLength);
}
void
PackageLinksDirectory::UpdatePackageDependencies(Package* package)
{
NodeWriteLocker writeLocker(this);
PackageLinkDirectory* linkDirectory = package->LinkDirectory();
if (linkDirectory == NULL)
return;
linkDirectory->UpdatePackageDependencies(package, fListener);
}
void
PackageFSRoot::_RemoveVolume(Volume* volume)
{
PackageFSRootWriteLocker writeLocker(this);
if (volume == fSystemVolume)
fSystemVolume = NULL;
fVolumes.Remove(volume);
volume->SetPackageFSRoot(NULL);
}
bool BasicKeywordsModel::setDescription(const QString &value) {
QWriteLocker writeLocker(&m_DescriptionLock);
Q_UNUSED(writeLocker);
bool result = value != m_Description;
if (result) {
m_Description = value;
}
return result;
}
bool BasicKeywordsModel::setTitle(const QString &value) {
QWriteLocker writeLocker(&m_TitleLock);
Q_UNUSED(writeLocker);
bool result = value != m_Title;
if (result) {
m_Title = value;
}
return result;
}
status_t
PackageFSRoot::AddPackage(Package* package)
{
PackageFSRootWriteLocker writeLocker(this);
status_t error = _AddPackage(package);
if (error != B_OK) {
_RemovePackage(package);
RETURN_ERROR(error);
}
return B_OK;
}
KSvgRenderer* SvgHandler::getRenderer( const QString& name )
{
QReadLocker readLocker( &m_lock );
if( ! m_renderers[name] )
{
readLocker.unlock();
if( !loadSvg( name ) )
{
QWriteLocker writeLocker( &m_lock );
m_renderers[name] = new KSvgRenderer();
}
readLocker.relock();
}
return m_renderers[name];
}
status_t
PackageFSRoot::_AddVolume(Volume* volume)
{
PackageFSRootWriteLocker writeLocker(this);
volume->SetPackageFSRoot(this);
fVolumes.Add(volume);
// TODO: Correct order?
if (fSystemVolume == NULL && volume->MountType()
== PACKAGE_FS_MOUNT_TYPE_SYSTEM) {
fSystemVolume = volume;
}
return B_OK;
}
void
object_depot_make_empty(object_depot* depot, uint32 flags)
{
WriteLocker writeLocker(depot->outer_lock);
// collect the store magazines
DepotMagazine* storeMagazines = NULL;
int cpuCount = smp_get_num_cpus();
for (int i = 0; i < cpuCount; i++) {
depot_cpu_store& store = depot->stores[i];
if (store.loaded) {
_push(storeMagazines, store.loaded);
store.loaded = NULL;
}
if (store.previous) {
_push(storeMagazines, store.previous);
store.previous = NULL;
}
}
// detach the depot's full and empty magazines
DepotMagazine* fullMagazines = depot->full;
depot->full = NULL;
DepotMagazine* emptyMagazines = depot->empty;
depot->empty = NULL;
writeLocker.Unlock();
// free all magazines
while (storeMagazines != NULL)
empty_magazine(depot, _pop(storeMagazines), flags);
while (fullMagazines != NULL)
empty_magazine(depot, _pop(fullMagazines), flags);
while (emptyMagazines)
free_magazine(_pop(emptyMagazines), flags);
}
void PeerObject::readSocketDescriptor()
{
int fd = m_socket->read().toSocketDescriptor();
// qDebug(">>> readSocketDescriptor() : %x", fd);
QFile file;
// Try to open file
if(!file.open(fd, QIODevice::ReadOnly))
{
file.seek(0);
qDebug("Peer: PeerObject::readSocketDescriptor() - coudl not open file");
m_peerSocket->write(QStringLiteral("fReceived invalid file descriptor").toLatin1());
// m_peerSocket->flush();
if(m_close)
close(1);
return;
}
// Get filename
QString filename(QString::fromUtf8(file.readAll().trimmed()));
// qDebug("File is: %s (size: %lld)", qPrintable(filename), file.size());
// Save filename
QWriteLocker writeLocker(&m_dataFDLock);
m_dataFD.append(filename);
// Close file
file.close();
static int totalReadFDCount = 0;
totalReadFDCount++;
Logger::log("Handled file descriptors", totalReadFDCount);
callSlotQueued(this, "checkReadData");
}
status_t
PackageLinksDirectory::AddPackage(Package* package)
{
// Create a package link directory -- there might already be one, but since
// that's unlikely, we don't bother to check and recheck later.
PackageLinkDirectory* linkDirectory
= new(std::nothrow) PackageLinkDirectory;
if (linkDirectory == NULL)
return B_NO_MEMORY;
BReference<PackageLinkDirectory> linkDirectoryReference(linkDirectory,
true);
status_t error = linkDirectory->Init(this, package);
if (error != B_OK)
RETURN_ERROR(error);
// add the link directory
NodeWriteLocker writeLocker(this);
if (Node* child = FindChild(linkDirectory->Name())) {
// There already is an entry with the name.
PackageLinkDirectory* otherLinkDirectory
= dynamic_cast<PackageLinkDirectory*>(child);
if (otherLinkDirectory == NULL)
RETURN_ERROR(B_BAD_VALUE);
// There's already a package link directory. Delete the one we created
// and add the package to the pre-existing one.
linkDirectory->RemovePackage(package, NULL);
linkDirectory = otherLinkDirectory;
linkDirectory->AddPackage(package, fListener);
} else {
// No entry is in the way, so just add the link directory.
AddChild(linkDirectory);
if (fListener != NULL)
linkDirectory->NotifyDirectoryAdded(fListener);
}
return B_OK;
}
void BasicKeywordsModel::setSpellStatuses(BasicKeywordsModel *keywordsModel) {
QWriteLocker writeLocker(&m_KeywordsLock);
Q_UNUSED(writeLocker);
keywordsModel->lockKeywordsRead();
{
const QVector<bool> &spellStatuses = keywordsModel->getSpellStatusesUnsafe();
#ifdef QT_DEBUG
// sync issue between adding/removing/undo/spellcheck
Q_ASSERT(spellStatuses.length() == m_SpellCheckResults.length());
#endif
int size = qMin(spellStatuses.length(), m_SpellCheckResults.length());
for (int i = 0; i < size; ++i) {
m_SpellCheckResults[i] = spellStatuses[i];
}
}
keywordsModel->unlockKeywords();
}
void LocalSocketPrivate::setClosed()
{
QWriteLocker controlLock(&m_controlLock);
if(!m_isOpen)
return;
// qDebug("[%p] LocalSocketPrivate::setClosed()", this);
m_isOpen = false;
m_socketDescriptor = 0;
controlLock.unlock();
// Remove socket notifier
removeReadNotifier();
removeWriteNotifier();
removeExceptionNotifier();
QWriteLocker writeLocker(&m_writeBufferLock);
// Clear write data
if(m_currentlyWritingFileDescriptor)
delete m_currentlyWritingFileDescriptor;
m_currentlyWritingFileDescriptor = 0;
m_currentWriteData.clear();
m_currentWriteDataPos = 0;
m_writeBuffer.clear();
writeLocker.unlock();
// Clear temporary read data
m_currentReadData.clear();
m_tempReadBuffer.clear();
m_tempReadFileDescBuffer.clear();
emit(disconnected());
}
void
PackageLinksDirectory::RemovePackage(Package* package)
{
NodeWriteLocker writeLocker(this);
// get the package's link directory and remove the package from it
PackageLinkDirectory* linkDirectory = package->LinkDirectory();
if (linkDirectory == NULL)
return;
BReference<PackageLinkDirectory> linkDirectoryReference(linkDirectory);
linkDirectory->RemovePackage(package, fListener);
// if empty, remove the link directory itself
if (linkDirectory->IsEmpty()) {
if (fListener != NULL) {
NodeWriteLocker linkDirectoryWriteLocker(linkDirectory);
fListener->PackageLinkNodeRemoved(linkDirectory);
}
RemoveChild(linkDirectory);
}
}
void SampleBuffer::setEndFrame( const f_cnt_t _e )
{
QWriteLocker writeLocker(&m_varLock);
m_endFrame = _e;
}
void PeerObject::readData()
{
// static int readCount = 0;
// m_dbgLog.write("PeerObject::readData()");
// m_dbgLog.write(QString("(%1)\n").arg(++readCount).toLatin1());
// m_dbgLog.flush();
static quint64 totalRead = 0;
while(m_socket->availableData()) {
// Read size
quint32 orgSize = 0;
quint32 size = 0;
if(m_socket->bytesAvailable() < sizeof(size)) {
callSlotQueued(this, "checkReadData");
return;
}
if(m_socket->read((char *)&orgSize, sizeof(orgSize)) < sizeof(orgSize))
qFatal("Could not read size!");
size = qFromBigEndian<quint32>(orgSize);
// if(m_socket->read((char*)&size, sizeof(size)) < sizeof(size))
// qFatal("Could not checksum!");
// size = qFromBigEndian<quint32>(size);
// qDebug("Peer: size to read: %u", size);
if(size == 0) {
qDebug("Peer: PeerObject::readData() - zero size data");
m_peerSocket->write(QStringLiteral("fReceived zero size").toLatin1());
// m_peerSocket->flush();
if(m_close)
close(1);
return;
}
// Read data with specified size
QElapsedTimer timer;
QByteArray data(size, (char)'\0');
// qDebug("PeerObject::readData() - size: %u", size);
// m_dbgLog.write("Reading: ");
// m_dbgLog.write(QStringLiteral("%1 bytes").arg(size).toLatin1());
// m_dbgLog.write("\n");
// m_dbgLog.flush();
// Read max 30 seconds
timer.start();
qint64 tmp = 0;
qint64 read = 0;
bool waiting = false;
while(read < size && timer.elapsed() < 10000) {
if(m_socket->bytesAvailable() < 1) {
waiting = true;
// Logger::log("Read bytes (TestLocalSocket_Ext_PO)", totalRead + read, "bW", "Begin waiting for bytes");
if(m_socket->waitForReadyRead(10000 - timer.elapsed()))
timer.restart();
}
tmp = m_socket->read(data.data() + read, size - read);
if(tmp < 0) {
m_peerSocket->write(QStringLiteral("fCould not read data!").toLatin1());
// m_peerSocket->flush();
close(1);
return;
}
// Logger::log("Read tmp bytes (TestLocalSocket_Ext_PO)", tmp);
read += tmp;
}
// if(waiting)
// Logger::log("Read bytes (TestLocalSocket_Ext_PO)", totalRead + read, "eW", "End waiting for bytes");
// m_dbgLog.write("Ok\n");
// m_dbgLog.flush();
// Check read data size
if(read < size) {
qDebug("Peer: PeerObject::readData() - not enough data");
m_peerSocket->write(QStringLiteral("fDid not receive enough data. Expected: %1; Got: %2").arg(size).arg(data.size()).toLatin1());
// m_peerSocket->flush();
// m_dbgLog.write("Did not receive enough data");
// m_dbgLog.write("\n");
// m_dbgLog.flush();
if(m_close)
close(1);
return;
}
// printf("=== Data read (%lld/%d) ===\n", read, data.size());
// QByteArray tmpData(QByteArray((const char*)&orgSize, sizeof(orgSize)) + data);
// for(int i = 0; i < tmpData.size(); i++)
// printf("%02X", tmpData.constData()[i]);
// printf("\n=================\n");
// m_dbgLog.write("Locking: 170\n");// m_dbgLog.flush();
QWriteLocker writeLocker(&m_dataLock);
// m_dbgLog.write("Ok: 170\n");// m_dbgLog.flush();
// Store data
m_data.append(data);
static int totalReadCount = 0;
totalReadCount++;
Logger::log("Handled data", totalReadCount);
}
callSlotQueued(this, "checkReadData");
}
bool LocalSocketPrivate::waitForReadyRead(QElapsedTimer& timer, int timeout)
{
bool readyRead = false;
bool readyWrite = false;
// Don't disable and reenable the socket notifiers as it seems unneeded, costs a lot of cpu time and blocks at some time (with lots of sockets)
// disableReadNotifier();
// disableWriteNotifier();
// disableExceptionNotifier();
QReadLocker controlLock(&m_controlLock);
while(m_isOpen && (timeout > 0 ? timer.elapsed() < timeout : !readyWrite))
{
controlLock.unlock();
QReadLocker readLocker(&m_readBufferLock);
// We need to read
readyRead = m_readBuffer.isEmpty();
readLocker.unlock();
if(!readyRead)
return true;
QReadLocker writeLocker(&m_writeBufferLock);
// Do we need to write?
readyWrite = (!m_currentWriteData.isEmpty() || !m_writeBuffer.isEmpty());
writeLocker.unlock();
bool ret = waitForReadOrWrite(readyRead, readyWrite, (timeout > 0 ? timeout - timer.elapsed() : 0));
// Failed to wait
if(!ret)
{
controlLock.relock();
if(m_isOpen)
{
// Don't disable and reenable the socket notifiers as it seems unneeded, costs a lot of cpu time and blocks at some time (with lots of sockets)
// enableReadNotifier();
// enableWriteNotifier();
// enableExceptionNotifier();
}
return false;
}
// Read and write data if we can
if(readyWrite)
writeData();
if(readyRead)
readData();
if(readyRead)
break;
readyRead = false;
readyWrite = false;
}
controlLock.unlock();
// Don't disable and reenable the socket notifiers as it seems unneeded, costs a lot of cpu time and blocks at some time (with lots of sockets)
// enableReadNotifier();
// enableWriteNotifier();
// enableExceptionNotifier();
return readyRead;
}
void KisMultipleProjection::freeProjection(const QString &id)
{
QWriteLocker writeLocker(&m_d->lock);
m_d->planes.remove(id);
}
status_t
Inode::WriteAt(Transaction& transaction, off_t pos, const uint8* buffer,
size_t* _length)
{
TRACE("Inode::WriteAt(%lld, %p, *(%p) = %ld)\n", pos, buffer,
_length, *_length);
ReadLocker readLocker(fLock);
if (IsFileCacheDisabled())
return B_BAD_VALUE;
if (pos < 0)
return B_BAD_VALUE;
readLocker.Unlock();
TRACE("Inode::WriteAt(): Starting transaction\n");
transaction.Start(fVolume->GetJournal());
WriteLocker writeLocker(fLock);
TRACE("Inode::WriteAt(): Updating modification time\n");
struct timespec timespec;
_BigtimeToTimespec(real_time_clock_usecs(), ×pec);
SetModificationTime(×pec);
// NOTE: Debugging info to find why sometimes resize doesn't happen
size_t length = *_length;
#ifdef TRACE_EXT2
off_t oldEnd = pos + length;
TRACE("Inode::WriteAt(): Old calc for end? %x:%x\n",
(int)(oldEnd >> 32), (int)(oldEnd & 0xFFFFFFFF));
#endif
off_t end = pos + (off_t)length;
off_t oldSize = Size();
TRACE("Inode::WriteAt(): Old size: %x:%x, new size: %x:%x\n",
(int)(oldSize >> 32), (int)(oldSize & 0xFFFFFFFF),
(int)(end >> 32), (int)(end & 0xFFFFFFFF));
if (end > oldSize) {
status_t status = Resize(transaction, end);
if (status != B_OK) {
*_length = 0;
WriteLockInTransaction(transaction);
return status;
}
status = WriteBack(transaction);
if (status != B_OK) {
*_length = 0;
WriteLockInTransaction(transaction);
return status;
}
}
writeLocker.Unlock();
if (oldSize < pos)
FillGapWithZeros(oldSize, pos);
if (length == 0) {
// Probably just changed the file size with the pos parameter
return B_OK;
}
TRACE("Inode::WriteAt(): Performing write: %p, %lld, %p, %ld\n",
FileCache(), pos, buffer, *_length);
status_t status = file_cache_write(FileCache(), NULL, pos, buffer, _length);
WriteLockInTransaction(transaction);
TRACE("Inode::WriteAt(): Done\n");
return status;
}
void KisMultipleProjection::freeAllProjections()
{
QWriteLocker writeLocker(&m_d->lock);
m_d->planes.clear();
}
