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(); }