file_systems/bfs/Inode.cpp

143 							InodeAllocator(Transaction& transaction);
162 InodeAllocator::InodeAllocator(Transaction& transaction)
164 	fTransaction(&transaction),
301 		panic("transaction %d aborted, inode %p still around!\n", (int)id, inode);
373 Inode::Inode(Volume* volume, Transaction& transaction, ino_t id, mode_t mode,
383 	PRINT(("Inode::Inode(volume = %p, transaction = %p, id = %" B_PRIdINO
384 		") @ %p\n", volume, &transaction, id, this));
390 	status_t status = node.SetToWritable(transaction, this, true);
467 /*!	Adds this inode to the specified transaction. This means that the inode will
468 	be write locked until the transaction ended.
470 	is acquired to it as long as this transaction stays active.
473 Inode::WriteLockInTransaction(Transaction& transaction)
475 	// These flags can only change while holding the transaction lock
490 	transaction.AddListener(this);
495 Inode::WriteBack(Transaction& transaction)
498 	status_t status = node.SetToWritable(transaction, this);
560 Inode::_MakeSpaceForSmallData(Transaction& transaction, bfs_inode* node,
594 		status_t status = CreateAttribute(transaction, item->Name(),
600 		status = attribute->WriteAt(transaction, 0, item->Data(), &length);
608 				|| attributes->Remove(transaction, name) < B_OK) {
664 Inode::_RemoveSmallData(Transaction& transaction, NodeGetter& nodeGetter,
685 	status_t status = nodeGetter.MakeWritable(transaction);
694 		status = WriteBack(transaction);
708 	method - it's a bad API decision that it needs a transaction but enforces
713 Inode::_AddSmallData(Transaction& transaction, NodeGetter& nodeGetter,
728 	status_t status = nodeGetter.MakeWritable(transaction);
765 				if (_MakeSpaceForSmallData(transaction, node, name, needed)
830 		if (_MakeSpaceForSmallData(transaction, node, name, spaceNeeded) < B_OK)
970 Inode::SetName(Transaction& transaction, const char* name)
976 	status_t status = node.SetToWritable(transaction, this);
982 	return _AddSmallData(transaction, node, nameTag, FILE_NAME_TYPE, 0,
988 Inode::_RemoveAttribute(Transaction& transaction, const char* name,
1006 				index->Update(transaction, name, attribute->Type(), data,
1014 	if ((status = attributes->Remove(transaction, name)) < B_OK)
1018 		attributes->WriteLockInTransaction(transaction);
1024 			if (attributes->WriteBack(transaction) == B_OK) {
1026 				WriteBack(transaction);
1094 Inode::WriteAttribute(Transaction& transaction, const char* name, int32 type,
1124 		status = node.SetToWritable(transaction, this);
1146 		status = _AddSmallData(transaction, node, name, type, pos, buffer,
1152 				status = _RemoveSmallData(transaction, node, name);
1157 				status = CreateAttribute(transaction, name, type, &attribute);
1167 			status = WriteBack(transaction);
1197 		status = node.SetToWritable(transaction, this);
1201 		status = _AddSmallData(transaction, node, name, type, pos, buffer,
1207 			status = _RemoveAttribute(transaction, name, false, NULL);
1212 			status = attribute->WriteBack(transaction);
1216 				status = attribute->WriteAt(transaction, pos, buffer,
1226 			status = WriteBack(transaction);
1229 		attribute->WriteLockInTransaction(transaction);
1249 			index.Update(transaction, name, type, oldData, oldLength,
1266 Inode::RemoveAttribute(Transaction& transaction, const char* name)
1284 			index.Update(transaction, name, smallData->Type(),
1289 	status = _RemoveSmallData(transaction, node, name);
1292 		status = _RemoveAttribute(transaction, name, hasIndex, &index);
1296 			WriteBack(transaction);
1358 Inode::CreateAttribute(Transaction& transaction, const char* name, uint32 type,
1363 		status_t status = Inode::Create(transaction, this, NULL,
1374 	return Inode::Create(transaction, attributes, name,
1407 Inode::ContainerContentsChanged(Transaction& transaction)
1414 	return WriteBack(transaction);
1582 Inode::WriteAt(Transaction& transaction, off_t pos, const uint8* buffer,
1604 	// the transaction doesn't have to be started already
1605 	if (changeSize && !transaction.IsStarted())
1606 		transaction.Start(fVolume, BlockNumber());
1612 	if (!transaction.IsStarted()
1615 		transaction.Start(fVolume, BlockNumber());
1623 		status_t status = SetFileSize(transaction, pos + length);
1626 			WriteLockInTransaction(transaction);
1630 		// index here as part of the current transaction - this might just
1634 		// go into this transaction (we cannot wait until the file
1636 		status = WriteBack(transaction);
1638 			WriteLockInTransaction(transaction);
1655 	if (transaction.IsStarted())
1656 		WriteLockInTransaction(transaction);
1694 Inode::_AllocateBlockArray(Transaction& transaction, block_run& run,
1700 	status_t status = fVolume->Allocate(transaction, this, length, run,
1710 		status = cached.SetToWritable(transaction, block + i, true);
1723 Inode::_GrowStream(Transaction& transaction, off_t size)
1812 		status_t status = fVolume->Allocate(transaction, this, blocksRequested,
1863 				status = _AllocateBlockArray(transaction, data->indirect,
1903 				cached.MakeWritable(transaction);
1941 				status = fVolume->Free(transaction,
1958 				status = _AllocateBlockArray(transaction,
2008 						cached.MakeWritable(transaction);
2010 						status = _AllocateBlockArray(transaction,
2017 					status = cachedDirect.SetToWritable(transaction,
2079 Inode::_FreeStaticStreamArray(Transaction& transaction, int32 level,
2109 		status_t status = cached.SetToWritable(transaction, blockNumber + i);
2124 				status = _FreeStaticStreamArray(transaction, 1, array[index],
2127 				status = fVolume->Free(transaction, array[index]);
2153 Inode::_FreeStreamArray(Transaction& transaction, block_run* array,
2198 		if (fVolume->Free(transaction, run) < B_OK)
2206 Inode::_ShrinkStream(Transaction& transaction, off_t size)
2215 		status = _FreeStaticStreamArray(transaction, 0, data->double_indirect,
2221 			fVolume->Free(transaction, data->double_indirect);
2233 			status = cached.SetToWritable(transaction, block + i);
2242 			if (_FreeStreamArray(transaction, array, fVolume->BlockSize()
2247 			fVolume->Free(transaction, data->indirect);
2258 		status = _FreeStreamArray(transaction, data->direct, NUM_DIRECT_BLOCKS,
2270 Inode::SetFileSize(Transaction& transaction, off_t size)
2285 		status = _GrowStream(transaction, size);
2289 			_ShrinkStream(transaction, oldSize);
2292 		status = _ShrinkStream(transaction, size);
2300 	return WriteBack(transaction);
2305 Inode::Append(Transaction& transaction, off_t bytes)
2307 	return SetFileSize(transaction, Size() + bytes);
2335 Inode::TrimPreallocation(Transaction& transaction)
2340 	status_t status = _ShrinkStream(transaction, Size());
2344 	return WriteBack(transaction);
2350 Inode::Free(Transaction& transaction)
2358 		status_t status = SetFileSize(transaction, 0);
2374 			RemoveAttribute(transaction, name);
2378 	if (WriteBack(transaction) < B_OK)
2381 	return fVolume->Free(transaction, BlockRun());
2521 Inode::Remove(Transaction& transaction, const char* name, ino_t* _id,
2527 	WriteLockInTransaction(transaction);
2542 		return fTree->Remove(transaction, name, id);
2546 	inode->WriteLockInTransaction(transaction);
2567 	if (fTree->Remove(transaction, name, id) != B_OK && !force) {
2578 	ContainerContentsChanged(transaction);
2589 		index.RemoveName(transaction, name, inode);
2596 		index.RemoveSize(transaction, inode);
2598 		index.RemoveLastModified(transaction, inode);
2600 	return inode->WriteBack(transaction);
2620 Inode::Create(Transaction& transaction, Inode* parent, const char* name,
2627 	Volume* volume = transaction.GetVolume();
2637 		parent->WriteLockInTransaction(transaction);
2678 				inode->WriteLockInTransaction(transaction);
2680 				status_t status = inode->SetFileSize(transaction, 0);
2682 					status = inode->WriteBack(transaction);
2716 	InodeAllocator allocator(transaction);
2745 	inode->WriteBack(transaction);
2751 		&& inode->SetName(transaction, name) != B_OK)
2766 		status = tree->Insert(transaction, name, inode->ID());
2769 		status = parent->WriteBack(transaction);
2786 		status = index.InsertName(transaction, name, inode);
2792 				tree->Remove(transaction, name, inode->ID());
2801 		parent->ContainerContentsChanged(transaction);
2809 		index.InsertSize(transaction, inode);
2811 		index.InsertLastModified(transaction, inode);