/*
 * Copyright 2009, Bryce Groff, bgroff@hawaii.edu.
 * Copyright 2004-2009, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2003-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 *
 * Distributed under the terms of the MIT License.
 */


#include <KPartition.h>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <DiskDeviceRoster.h>
#include <Drivers.h>
#include <Errors.h>
#include <fs_volume.h>
#include <KernelExport.h>
#include <StackOrHeapArray.h>

#include <ddm_userland_interface.h>
#include <fs/devfs.h>
#include <KDiskDevice.h>
#include <KDiskDeviceManager.h>
#include <KDiskDeviceUtils.h>
#include <KDiskSystem.h>
#include <KPartitionListener.h>
#include <KPartitionVisitor.h>
#include <KPath.h>
#include <util/kernel_cpp.h>
#include <VectorSet.h>
#include <vfs.h>

#include "UserDataWriter.h"


using namespace std;


// debugging
//#define DBG(x)
#define DBG(x) x
#define OUT dprintf


struct KPartition::ListenerSet : VectorSet<KPartitionListener*> {};


int32 KPartition::sNextID = 0;


KPartition::KPartition(partition_id id)
        :
        fPartitionData(),
        fChildren(),
        fDevice(NULL),
        fParent(NULL),
        fDiskSystem(NULL),
        fDiskSystemPriority(-1),
        fListeners(NULL),
        fChangeFlags(0),
        fChangeCounter(0),
        fAlgorithmData(0),
        fReferenceCount(0),
        fObsolete(false),
        fPublishedName(NULL)
{
        fPartitionData.id = id >= 0 ? id : _NextID();
        fPartitionData.offset = 0;
        fPartitionData.size = 0;
        fPartitionData.content_size = 0;
        fPartitionData.block_size = 0;
        fPartitionData.physical_block_size = 0;
        fPartitionData.child_count = 0;
        fPartitionData.index = -1;
        fPartitionData.status = B_PARTITION_UNRECOGNIZED;
        fPartitionData.flags = B_PARTITION_BUSY;
        fPartitionData.volume = -1;
        fPartitionData.name = NULL;
        fPartitionData.content_name = NULL;
        fPartitionData.type = NULL;
        fPartitionData.content_type = NULL;
        fPartitionData.parameters = NULL;
        fPartitionData.content_parameters = NULL;
        fPartitionData.cookie = NULL;
        fPartitionData.content_cookie = NULL;
}


KPartition::~KPartition()
{
        delete fListeners;
        SetDiskSystem(NULL);
        free(fPartitionData.name);
        free(fPartitionData.content_name);
        free(fPartitionData.type);
        free(fPartitionData.parameters);
        free(fPartitionData.content_parameters);
}


void
KPartition::Register()
{
        fReferenceCount++;
}


void
KPartition::Unregister()
{
        KDiskDeviceManager* manager = KDiskDeviceManager::Default();
        ManagerLocker locker(manager);
        fReferenceCount--;
        if (IsObsolete() && fReferenceCount == 0) {
                // let the manager delete object
                manager->DeletePartition(this);
        }
}


int32
KPartition::CountReferences() const
{
        return fReferenceCount;
}


void
KPartition::MarkObsolete()
{
        fObsolete = true;
}


bool
KPartition::IsObsolete() const
{
        return fObsolete;
}


bool
KPartition::PrepareForRemoval()
{
        bool result = RemoveAllChildren();
        UninitializeContents();
        UnpublishDevice();
        if (ParentDiskSystem())
                ParentDiskSystem()->FreeCookie(this);
        if (DiskSystem())
                DiskSystem()->FreeContentCookie(this);
        return result;
}


bool
KPartition::PrepareForDeletion()
{
        return true;
}


status_t
KPartition::Open(int flags, int* fd)
{
        if (!fd)
                return B_BAD_VALUE;

        // get the path
        KPath path;
        status_t error = GetPath(&path);
        if (error != B_OK)
                return error;

        // open the device
        *fd = open(path.Path(), flags);
        if (*fd < 0)
                return errno;

        return B_OK;
}


status_t
KPartition::PublishDevice()
{
        if (fPublishedName)
                return B_OK;

        // get the name to publish
        char buffer[B_FILE_NAME_LENGTH];
        status_t error = GetFileName(buffer, B_FILE_NAME_LENGTH);
        if (error != B_OK)
                return error;

        // prepare a partition_info
        partition_info info;
        info.offset = Offset();
        info.size = Size();
        info.logical_block_size = BlockSize();
        info.physical_block_size = PhysicalBlockSize();
        info.session = 0;
        info.partition = ID();
        if (strlcpy(info.device, Device()->Path(), sizeof(info.device))
                        >= sizeof(info.device)) {
                return B_NAME_TOO_LONG;
        }

        fPublishedName = strdup(buffer);
        if (!fPublishedName)
                return B_NO_MEMORY;

        error = devfs_publish_partition(buffer, &info);
        if (error != B_OK) {
                dprintf("KPartition::PublishDevice(): Failed to publish partition "
                        "%" B_PRId32 ": %s\n", ID(), strerror(error));
                free(fPublishedName);
                fPublishedName = NULL;
                return error;
        }

        return B_OK;
}


status_t
KPartition::UnpublishDevice()
{
        if (!fPublishedName)
                return B_OK;

        // get the path
        KPath path;
        status_t error = GetPath(&path);
        if (error != B_OK) {
                dprintf("KPartition::UnpublishDevice(): Failed to get path for "
                        "partition %" B_PRId32 ": %s\n", ID(), strerror(error));
                return error;
        }

        error = devfs_unpublish_partition(path.Path());
        if (error != B_OK) {
                dprintf("KPartition::UnpublishDevice(): Failed to unpublish partition "
                        "%" B_PRId32 ": %s\n", ID(), strerror(error));
        }

        free(fPublishedName);
        fPublishedName = NULL;

        return error;
}


status_t
KPartition::RepublishDevice()
{
        if (!fPublishedName)
                return B_OK;

        char newNameBuffer[B_FILE_NAME_LENGTH];
        status_t error = GetFileName(newNameBuffer, B_FILE_NAME_LENGTH);
        if (error != B_OK) {
                UnpublishDevice();
                return error;
        }

        if (strcmp(fPublishedName, newNameBuffer) == 0)
                return B_OK;

        for (int i = 0; i < CountChildren(); i++)
                ChildAt(i)->RepublishDevice();

        char* newName = strdup(newNameBuffer);
        if (!newName) {
                UnpublishDevice();
                return B_NO_MEMORY;
        }

        error = devfs_rename_partition(Device()->Path(), fPublishedName, newName);

        if (error != B_OK) {
                free(newName);
                UnpublishDevice();
                dprintf("KPartition::RepublishDevice(): Failed to republish partition "
                        "%" B_PRId32 ": %s\n", ID(), strerror(error));
                return error;
        }

        free(fPublishedName);
        fPublishedName = newName;

        return B_OK;
}


bool
KPartition::IsPublished() const
{
        return fPublishedName != NULL;
}


void
KPartition::SetBusy(bool busy)
{
        if (busy)
                AddFlags(B_PARTITION_BUSY);
        else
                ClearFlags(B_PARTITION_BUSY);
}


bool
KPartition::IsBusy() const
{
        return (fPartitionData.flags & B_PARTITION_BUSY) != 0;
}


bool
KPartition::IsBusy(bool includeDescendants)
{
        if (!includeDescendants)
                return IsBusy();

        struct IsBusyVisitor : KPartitionVisitor {
                virtual bool VisitPre(KPartition* partition)
                {
                        return partition->IsBusy();
                }
        } checkVisitor;

        return VisitEachDescendant(&checkVisitor) != NULL;
}


bool
KPartition::CheckAndMarkBusy(bool includeDescendants)
{
        if (IsBusy(includeDescendants))
                return false;

        MarkBusy(includeDescendants);

        return true;
}


void
KPartition::MarkBusy(bool includeDescendants)
{
        if (includeDescendants) {
                struct MarkBusyVisitor : KPartitionVisitor {
                        virtual bool VisitPre(KPartition* partition)
                        {
                                partition->AddFlags(B_PARTITION_BUSY);
                                return false;
                        }
                } markVisitor;

                VisitEachDescendant(&markVisitor);
        } else
                SetBusy(true);
}


void
KPartition::UnmarkBusy(bool includeDescendants)
{
        if (includeDescendants) {
                struct UnmarkBusyVisitor : KPartitionVisitor {
                        virtual bool VisitPre(KPartition* partition)
                        {
                                partition->ClearFlags(B_PARTITION_BUSY);
                                return false;
                        }
                } visitor;

                VisitEachDescendant(&visitor);
        } else
                SetBusy(false);
}


void
KPartition::SetOffset(off_t offset)
{
        if (fPartitionData.offset != offset) {
                fPartitionData.offset = offset;
                FireOffsetChanged(offset);
        }
}


off_t
KPartition::Offset() const
{
        return fPartitionData.offset;
}


void
KPartition::SetSize(off_t size)
{
        if (fPartitionData.size != size) {
                fPartitionData.size = size;
                FireSizeChanged(size);
        }
}


off_t
KPartition::Size() const
{
        return fPartitionData.size;
}


void
KPartition::SetContentSize(off_t size)
{
        if (fPartitionData.content_size != size) {
                fPartitionData.content_size = size;
                FireContentSizeChanged(size);
        }
}


off_t
KPartition::ContentSize() const
{
        return fPartitionData.content_size;
}


void
KPartition::SetBlockSize(uint32 blockSize)
{
        if (fPartitionData.block_size != blockSize) {
                fPartitionData.block_size = blockSize;
                FireBlockSizeChanged(blockSize);
        }
}


uint32
KPartition::BlockSize() const
{
        return fPartitionData.block_size;
}


uint32
KPartition::PhysicalBlockSize() const
{
        return fPartitionData.physical_block_size;
}


void
KPartition::SetPhysicalBlockSize(uint32 blockSize)
{
        if (fPartitionData.physical_block_size != blockSize)
                fPartitionData.physical_block_size = blockSize;
}


void
KPartition::SetIndex(int32 index)
{
        if (fPartitionData.index != index) {
                fPartitionData.index = index;
                FireIndexChanged(index);
        }
}


int32
KPartition::Index() const
{
        return fPartitionData.index;
}


void
KPartition::SetStatus(uint32 status)
{
        if (fPartitionData.status != status) {
                fPartitionData.status = status;
                FireStatusChanged(status);
        }
}


uint32
KPartition::Status() const
{
        return fPartitionData.status;
}


bool
KPartition::IsUninitialized() const
{
        return Status() == B_PARTITION_UNINITIALIZED;
}


void
KPartition::SetFlags(uint32 flags)
{
        if (fPartitionData.flags != flags) {
                fPartitionData.flags = flags;
                FireFlagsChanged(flags);
        }
}


void
KPartition::AddFlags(uint32 flags)
{
        if (~fPartitionData.flags & flags) {
                fPartitionData.flags |= flags;
                FireFlagsChanged(fPartitionData.flags);
        }
}


void
KPartition::ClearFlags(uint32 flags)
{
        if (fPartitionData.flags & flags) {
                fPartitionData.flags &= ~flags;
                FireFlagsChanged(fPartitionData.flags);
        }
}


uint32
KPartition::Flags() const
{
        return fPartitionData.flags;
}


bool
KPartition::ContainsFileSystem() const
{
        return (fPartitionData.flags & B_PARTITION_FILE_SYSTEM) != 0;
}


bool
KPartition::ContainsPartitioningSystem() const
{
        return (fPartitionData.flags & B_PARTITION_PARTITIONING_SYSTEM) != 0;
}


bool
KPartition::IsReadOnly() const
{
        return (fPartitionData.flags & B_PARTITION_READ_ONLY) != 0;
}


bool
KPartition::IsMounted() const
{
        return (fPartitionData.flags & B_PARTITION_MOUNTED) != 0;
}


bool
KPartition::IsChildMounted()
{
        struct IsMountedVisitor : KPartitionVisitor {
                virtual bool VisitPre(KPartition* partition)
                {
                        return partition->IsMounted();
                }
        } checkVisitor;

        return VisitEachDescendant(&checkVisitor) != NULL;
}


bool
KPartition::IsDevice() const
{
        return (fPartitionData.flags & B_PARTITION_IS_DEVICE) != 0;
}


status_t
KPartition::SetName(const char* name)
{
        status_t error = set_string(fPartitionData.name, name);
        FireNameChanged(fPartitionData.name);
        return error;
}


const char*
KPartition::Name() const
{
        return fPartitionData.name;
}


status_t
KPartition::SetContentName(const char* name)
{
        status_t error = set_string(fPartitionData.content_name, name);
        FireContentNameChanged(fPartitionData.content_name);
        return error;
}


const char*
KPartition::ContentName() const
{
        return fPartitionData.content_name;
}


status_t
KPartition::SetType(const char* type)
{
        status_t error = set_string(fPartitionData.type, type);
        FireTypeChanged(fPartitionData.type);
        return error;
}


const char*
KPartition::Type() const
{
        return fPartitionData.type;
}


const char*
KPartition::ContentType() const
{
        return fPartitionData.content_type;
}


partition_data*
KPartition::PartitionData()
{
        return &fPartitionData;
}


const partition_data*
KPartition::PartitionData() const
{
        return &fPartitionData;
}


void
KPartition::SetID(partition_id id)
{
        if (fPartitionData.id != id) {
                fPartitionData.id = id;
                FireIDChanged(id);
        }
}


partition_id
KPartition::ID() const
{
        return fPartitionData.id;
}


status_t
KPartition::GetFileName(char* buffer, size_t size) const
{
        // If the parent is the device, the name is the index of the partition.
        if (Parent() == NULL || Parent()->IsDevice()) {
                if (snprintf(buffer, size, "%" B_PRId32, Index()) >= (int)size)
                        return B_NAME_TOO_LONG;
                return B_OK;
        }

        // The partition has a non-device parent, so we append the index to the
        // parent partition's name.
        status_t error = Parent()->GetFileName(buffer, size);
        if (error != B_OK)
                return error;

        size_t len = strlen(buffer);
        if (snprintf(buffer + len, size - len, "_%" B_PRId32, Index()) >= int(size - len))
                return B_NAME_TOO_LONG;
        return B_OK;
}


status_t
KPartition::GetPath(KPath* path) const
{
        // For a KDiskDevice this version is never invoked, so the check for
        // Parent() is correct.
        if (!path || path->InitCheck() != B_OK || !Parent() || Index() < 0)
                return B_BAD_VALUE;

        // init the path with the device path
        status_t error = path->SetPath(Device()->Path());
        if (error != B_OK)
                return error;

        // replace the leaf name with the partition's file name
        char name[B_FILE_NAME_LENGTH];
        error = GetFileName(name, sizeof(name));
        if (error == B_OK)
                error = path->ReplaceLeaf(name);

        return error;
}


status_t
KPartition::GetMountPoint(KPath* mountPoint) const
{
        if (!mountPoint || !ContainsFileSystem())
                return B_BAD_VALUE;

        ASSERT(!IsMounted());
                // fetching the actual mounted point isn't implemented (yet)

        int nameLength = 0;
        const char* volumeName = ContentName();
        if (volumeName != NULL)
                nameLength = strlen(volumeName);
        if (nameLength == 0) {
                volumeName = Name();
                if (volumeName != NULL)
                        nameLength = strlen(volumeName);
                if (nameLength == 0) {
                        volumeName = "unnamed volume";
                        nameLength = strlen(volumeName);
                }
        }

        BStackOrHeapArray<char, 128> basePath(nameLength + 2);
        if (!basePath.IsValid())
                return B_NO_MEMORY;
        int32 len = snprintf(basePath, nameLength + 2, "/%s", volumeName);
        for (int32 i = 1; i < len; i++)
                if (basePath[i] == '/')
                        basePath[i] = '-';
        char* path = mountPoint->LockBuffer();
        int32 pathLen = mountPoint->BufferSize();
        strncpy(path, basePath, pathLen);

        struct stat dummy;
        for (int i = 1; ; i++) {
                if (stat(path, &dummy) != 0)
                        break;
                snprintf(path, pathLen, "%s%d", (char*)basePath, i);
        }

        mountPoint->UnlockBuffer();
        return B_OK;
}


void
KPartition::SetVolumeID(dev_t volumeID)
{
        if (fPartitionData.volume == volumeID)
                return;

        fPartitionData.volume = volumeID;
        FireVolumeIDChanged(volumeID);
        if (VolumeID() >= 0)
                AddFlags(B_PARTITION_MOUNTED);
        else
                ClearFlags(B_PARTITION_MOUNTED);

        KDiskDeviceManager* manager = KDiskDeviceManager::Default();

        char messageBuffer[512];
        KMessage message;
        message.SetTo(messageBuffer, sizeof(messageBuffer), B_DEVICE_UPDATE);
        message.AddInt32("event", volumeID >= 0
                ? B_DEVICE_PARTITION_MOUNTED : B_DEVICE_PARTITION_UNMOUNTED);
        message.AddInt32("id", ID());
        if (volumeID >= 0)
                message.AddInt32("volume", volumeID);

        manager->Notify(message, B_DEVICE_REQUEST_MOUNTING);
}


dev_t
KPartition::VolumeID() const
{
        return fPartitionData.volume;
}


status_t
KPartition::SetParameters(const char* parameters)
{
        status_t error = set_string(fPartitionData.parameters, parameters);
        FireParametersChanged(fPartitionData.parameters);
        return error;
}


const char*
KPartition::Parameters() const
{
        return fPartitionData.parameters;
}


status_t
KPartition::SetContentParameters(const char* parameters)
{
        status_t error = set_string(fPartitionData.content_parameters, parameters);
        FireContentParametersChanged(fPartitionData.content_parameters);
        return error;
}


const char*
KPartition::ContentParameters() const
{
        return fPartitionData.content_parameters;
}


void
KPartition::SetDevice(KDiskDevice* device)
{
        fDevice = device;
        if (fDevice != NULL && fDevice->IsReadOnlyMedia())
                AddFlags(B_PARTITION_READ_ONLY);
}


KDiskDevice*
KPartition::Device() const
{
        return fDevice;
}


KPartition*
KPartition::Parent() const
{
        return fParent;
}


status_t
KPartition::AddChild(KPartition* partition, int32 index)
{
        // check parameters
        int32 count = fPartitionData.child_count;
        if (index == -1)
                index = count;
        if (index < 0 || index > count || !partition)
                return B_BAD_VALUE;

        // add partition
        KDiskDeviceManager* manager = KDiskDeviceManager::Default();
        if (ManagerLocker locker = manager) {
                status_t error = fChildren.Insert(partition, index);
                if (error != B_OK)
                        return error;
                if (!manager->PartitionAdded(partition)) {
                        fChildren.Erase(index);
                        return B_NO_MEMORY;
                }
                // update siblings index's
                partition->SetIndex(index);
                _UpdateChildIndices(count, index);
                fPartitionData.child_count++;

                partition->fParent = this;
                partition->SetDevice(Device());
                partition->SetPhysicalBlockSize(PhysicalBlockSize());

                // publish to devfs
                partition->PublishDevice();

                // notify listeners
                FireChildAdded(partition, index);
                return B_OK;
        }
        return B_ERROR;
}


status_t
KPartition::CreateChild(partition_id id, int32 index, off_t offset, off_t size,
        KPartition** _child)
{
        // check parameters
        int32 count = fPartitionData.child_count;
        if (index == -1)
                index = count;
        if (index < 0 || index > count)
                return B_BAD_VALUE;

        // create and add partition
        KPartition* child = new(std::nothrow) KPartition(id);
        if (child == NULL)
                return B_NO_MEMORY;

        child->SetOffset(offset);
        child->SetSize(size);

        status_t error = AddChild(child, index);

        // cleanup / set result
        if (error != B_OK)
                delete child;
        else if (_child)
                *_child = child;

        return error;
}


bool
KPartition::RemoveChild(int32 index)
{
        if (index < 0 || index >= fPartitionData.child_count)
                return false;

        KDiskDeviceManager* manager = KDiskDeviceManager::Default();
        if (ManagerLocker locker = manager) {
                KPartition* partition = fChildren.ElementAt(index);
                PartitionRegistrar _(partition);
                if (!partition || !manager->PartitionRemoved(partition)
                        || !fChildren.Erase(index)) {
                        return false;
                }
                _UpdateChildIndices(index, fChildren.Count());
                partition->SetIndex(-1);
                fPartitionData.child_count--;
                partition->fParent = NULL;
                partition->SetDevice(NULL);
                // notify listeners
                FireChildRemoved(partition, index);
                return true;
        }
        return false;
}


bool
KPartition::RemoveChild(KPartition* child)
{
        if (child) {
                int32 index = fChildren.IndexOf(child);
                if (index >= 0)
                        return RemoveChild(index);
        }
        return false;
}


bool
KPartition::RemoveAllChildren()
{
        int32 count = CountChildren();
        for (int32 i = count - 1; i >= 0; i--) {
                if (!RemoveChild(i))
                        return false;
        }
        return true;
}


KPartition*
KPartition::ChildAt(int32 index) const
{
        return index >= 0 && index < fChildren.Count()
                ? fChildren.ElementAt(index) : NULL;
}


int32
KPartition::CountChildren() const
{
        return fPartitionData.child_count;
}


int32
KPartition::CountDescendants() const
{
        int32 count = 1;
        for (int32 i = 0; KPartition* child = ChildAt(i); i++)
                count += child->CountDescendants();
        return count;
}


KPartition*
KPartition::VisitEachDescendant(KPartitionVisitor* visitor)
{
        if (!visitor)
                return NULL;
        if (visitor->VisitPre(this))
                return this;
        for (int32 i = 0; KPartition* child = ChildAt(i); i++) {
                if (KPartition* result = child->VisitEachDescendant(visitor))
                        return result;
        }
        if (visitor->VisitPost(this))
                return this;
        return NULL;
}


void
KPartition::SetDiskSystem(KDiskSystem* diskSystem, float priority)
{
        // unload former disk system
        if (fDiskSystem) {
                fPartitionData.content_type = NULL;
                fDiskSystem->Unload();
                fDiskSystem = NULL;
                fDiskSystemPriority = -1;
        }
        // set and load new one
        fDiskSystem = diskSystem;
        if (fDiskSystem) {
                fDiskSystem->Load();
                        // can't fail, since it's already loaded
        }
        // update concerned partition flags
        if (fDiskSystem) {
                fPartitionData.content_type = fDiskSystem->PrettyName();
                fDiskSystemPriority = priority;
                if (fDiskSystem->IsFileSystem())
                        AddFlags(B_PARTITION_FILE_SYSTEM);
                else
                        AddFlags(B_PARTITION_PARTITIONING_SYSTEM);
        }
        // notify listeners
        FireDiskSystemChanged(fDiskSystem);

        KDiskDeviceManager* manager = KDiskDeviceManager::Default();

        char messageBuffer[512];
        KMessage message;
        message.SetTo(messageBuffer, sizeof(messageBuffer), B_DEVICE_UPDATE);
        message.AddInt32("event", B_DEVICE_PARTITION_INITIALIZED);
        message.AddInt32("id", ID());

        manager->Notify(message, B_DEVICE_REQUEST_PARTITION);
}


KDiskSystem*
KPartition::DiskSystem() const
{
        return fDiskSystem;
}


float
KPartition::DiskSystemPriority() const
{
        return fDiskSystemPriority;
}


KDiskSystem*
KPartition::ParentDiskSystem() const
{
        return Parent() ? Parent()->DiskSystem() : NULL;
}


void
KPartition::SetCookie(void* cookie)
{
        if (fPartitionData.cookie != cookie) {
                fPartitionData.cookie = cookie;
                FireCookieChanged(cookie);
        }
}


void*
KPartition::Cookie() const
{
        return fPartitionData.cookie;
}


void
KPartition::SetContentCookie(void* cookie)
{
        if (fPartitionData.content_cookie != cookie) {
                fPartitionData.content_cookie = cookie;
                FireContentCookieChanged(cookie);
        }
}


void*
KPartition::ContentCookie() const
{
        return fPartitionData.content_cookie;
}


bool
KPartition::AddListener(KPartitionListener* listener)
{
        if (!listener)
                return false;
        // lazy create listeners
        if (!fListeners) {
                fListeners = new(nothrow) ListenerSet;
                if (!fListeners)
                        return false;
        }
        // add listener
        return fListeners->Insert(listener) == B_OK;
}


bool
KPartition::RemoveListener(KPartitionListener* listener)
{
        if (!listener || !fListeners)
                return false;
        // remove listener and delete the set, if empty now
        bool result = (fListeners->Remove(listener) > 0);
        if (fListeners->IsEmpty()) {
                delete fListeners;
                fListeners = NULL;
        }
        return result;
}


void
KPartition::Changed(uint32 flags, uint32 clearFlags)
{
        fChangeFlags &= ~clearFlags;
        fChangeFlags |= flags;
        fChangeCounter++;
        if (Parent())
                Parent()->Changed(B_PARTITION_CHANGED_DESCENDANTS);
}


void
KPartition::SetChangeFlags(uint32 flags)
{
        fChangeFlags = flags;
}


uint32
KPartition::ChangeFlags() const
{
        return fChangeFlags;
}


int32
KPartition::ChangeCounter() const
{
        return fChangeCounter;
}


status_t
KPartition::UninitializeContents(bool logChanges)
{
        if (DiskSystem()) {
                uint32 flags = B_PARTITION_CHANGED_INITIALIZATION
                        | B_PARTITION_CHANGED_CONTENT_TYPE
                        | B_PARTITION_CHANGED_STATUS
                        | B_PARTITION_CHANGED_FLAGS;

                // children
                if (CountChildren() > 0) {
                        if (!RemoveAllChildren())
                                return B_ERROR;
                        flags |= B_PARTITION_CHANGED_CHILDREN;
                }

                // volume
                if (VolumeID() >= 0) {
                        status_t error = vfs_unmount(VolumeID(),
                                B_FORCE_UNMOUNT | B_UNMOUNT_BUSY_PARTITION);
                        if (error != B_OK) {
                                dprintf("KPartition::UninitializeContents(): Failed to unmount "
                                        "device %" B_PRIdDEV ": %s\n", VolumeID(), strerror(error));
                        }

                        SetVolumeID(-1);
                        flags |= B_PARTITION_CHANGED_VOLUME;
                }

                // content name
                if (ContentName()) {
                        SetContentName(NULL);
                        flags |= B_PARTITION_CHANGED_CONTENT_NAME;
                }

                // content parameters
                if (ContentParameters()) {
                        SetContentParameters(NULL);
                        flags |= B_PARTITION_CHANGED_CONTENT_PARAMETERS;
                }

                // content size
                if (ContentSize() > 0) {
                        SetContentSize(0);
                        flags |= B_PARTITION_CHANGED_CONTENT_SIZE;
                }

                // block size
                if (Parent() && Parent()->BlockSize() != BlockSize()) {
                        SetBlockSize(Parent()->BlockSize());
                        flags |= B_PARTITION_CHANGED_BLOCK_SIZE;
                }

                // disk system
                DiskSystem()->FreeContentCookie(this);
                SetDiskSystem(NULL);

                // status
                SetStatus(B_PARTITION_UNINITIALIZED);

                // flags
                ClearFlags(B_PARTITION_FILE_SYSTEM | B_PARTITION_PARTITIONING_SYSTEM);
                if (!Device()->IsReadOnlyMedia())
                        ClearFlags(B_PARTITION_READ_ONLY);

                // log changes
                if (logChanges) {
                        Changed(flags, B_PARTITION_CHANGED_DEFRAGMENTATION
                                | B_PARTITION_CHANGED_CHECK | B_PARTITION_CHANGED_REPAIR);
                }
        }

        return B_OK;
}


void
KPartition::SetAlgorithmData(uint32 data)
{
        fAlgorithmData = data;
}


uint32
KPartition::AlgorithmData() const
{
        return fAlgorithmData;
}


void
KPartition::WriteUserData(UserDataWriter& writer, user_partition_data* data)
{
        // allocate
        char* name = writer.PlaceString(Name());
        char* contentName = writer.PlaceString(ContentName());
        char* type = writer.PlaceString(Type());
        char* contentType = writer.PlaceString(ContentType());
        char* parameters = writer.PlaceString(Parameters());
        char* contentParameters = writer.PlaceString(ContentParameters());
        // fill in data
        if (data) {
                data->id = ID();
                data->offset = Offset();
                data->size = Size();
                data->content_size = ContentSize();
                data->block_size = BlockSize();
                data->physical_block_size = PhysicalBlockSize();
                data->status = Status();
                data->flags = Flags();
                data->volume = VolumeID();
                data->index = Index();
                data->change_counter = ChangeCounter();
                data->disk_system = (DiskSystem() ? DiskSystem()->ID() : -1);
                data->name = name;
                data->content_name = contentName;
                data->type = type;
                data->content_type = contentType;
                data->parameters = parameters;
                data->content_parameters = contentParameters;
                data->child_count = CountChildren();
                // make buffer relocatable
                writer.AddRelocationEntry(&data->name);
                writer.AddRelocationEntry(&data->content_name);
                writer.AddRelocationEntry(&data->type);
                writer.AddRelocationEntry(&data->content_type);
                writer.AddRelocationEntry(&data->parameters);
                writer.AddRelocationEntry(&data->content_parameters);
        }
        // children
        for (int32 i = 0; KPartition* child = ChildAt(i); i++) {
                user_partition_data* childData
                        = writer.AllocatePartitionData(child->CountChildren());
                if (data) {
                        data->children[i] = childData;
                        writer.AddRelocationEntry(&data->children[i]);
                }
                child->WriteUserData(writer, childData);
        }
}


void
KPartition::Dump(bool deep, int32 level)
{
        if (level < 0 || level > 255)
                return;

        char prefix[256];
        sprintf(prefix, "%*s%*s", (int)level, "", (int)level, "");
        KPath path;
        GetPath(&path);
        if (level > 0)
                OUT("%spartition %" B_PRId32 ": %s\n", prefix, ID(), path.Path());
        OUT("%s  offset:            %" B_PRIdOFF "\n", prefix, Offset());
        OUT("%s  size:              %" B_PRIdOFF " (%.2f MB)\n", prefix, Size(),
                Size() / (1024.0*1024));
        OUT("%s  content size:      %" B_PRIdOFF "\n", prefix, ContentSize());
        OUT("%s  block size:        %" B_PRIu32 "\n", prefix, BlockSize());
        OUT("%s  physical block size: %" B_PRIu32 "\n", prefix, PhysicalBlockSize());
        OUT("%s  child count:       %" B_PRId32 "\n", prefix, CountChildren());
        OUT("%s  index:             %" B_PRId32 "\n", prefix, Index());
        OUT("%s  status:            %" B_PRIu32 "\n", prefix, Status());
        OUT("%s  flags:             %" B_PRIx32 "\n", prefix, Flags());
        OUT("%s  volume:            %" B_PRIdDEV "\n", prefix, VolumeID());
        OUT("%s  disk system:       %s\n", prefix,
                (DiskSystem() ? DiskSystem()->Name() : NULL));
        OUT("%s  name:              %s\n", prefix, Name());
        OUT("%s  content name:      %s\n", prefix, ContentName());
        OUT("%s  type:              %s\n", prefix, Type());
        OUT("%s  content type:      %s\n", prefix, ContentType());
        OUT("%s  params:            %s\n", prefix, Parameters());
        OUT("%s  content params:    %s\n", prefix, ContentParameters());
        if (deep) {
                for (int32 i = 0; KPartition* child = ChildAt(i); i++)
                        child->Dump(true, level + 1);
        }
}


void
KPartition::FireOffsetChanged(off_t offset)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->OffsetChanged(this, offset);
                }
        }
}


void
KPartition::FireSizeChanged(off_t size)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->SizeChanged(this, size);
                }
        }
}


void
KPartition::FireContentSizeChanged(off_t size)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ContentSizeChanged(this, size);
                }
        }
}


void
KPartition::FireBlockSizeChanged(uint32 blockSize)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->BlockSizeChanged(this, blockSize);
                }
        }
}


void
KPartition::FireIndexChanged(int32 index)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->IndexChanged(this, index);
                }
        }
}


void
KPartition::FireStatusChanged(uint32 status)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->StatusChanged(this, status);
                }
        }
}


void
KPartition::FireFlagsChanged(uint32 flags)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->FlagsChanged(this, flags);
                }
        }
}


void
KPartition::FireNameChanged(const char* name)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->NameChanged(this, name);
                }
        }
}


void
KPartition::FireContentNameChanged(const char* name)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ContentNameChanged(this, name);
                }
        }
}


void
KPartition::FireTypeChanged(const char* type)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->TypeChanged(this, type);
                }
        }
}


void
KPartition::FireIDChanged(partition_id id)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->IDChanged(this, id);
                }
        }
}


void
KPartition::FireVolumeIDChanged(dev_t volumeID)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->VolumeIDChanged(this, volumeID);
                }
        }
}


void
KPartition::FireParametersChanged(const char* parameters)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ParametersChanged(this, parameters);
                }
        }
}


void
KPartition::FireContentParametersChanged(const char* parameters)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ContentParametersChanged(this, parameters);
                }
        }
}


void
KPartition::FireChildAdded(KPartition* child, int32 index)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ChildAdded(this, child, index);
                }
        }
}


void
KPartition::FireChildRemoved(KPartition* child, int32 index)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ChildRemoved(this, child, index);
                }
        }
}


void
KPartition::FireDiskSystemChanged(KDiskSystem* diskSystem)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->DiskSystemChanged(this, diskSystem);
                }
        }
}


void
KPartition::FireCookieChanged(void* cookie)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->CookieChanged(this, cookie);
                }
        }
}


void
KPartition::FireContentCookieChanged(void* cookie)
{
        if (fListeners) {
                for (ListenerSet::Iterator it = fListeners->Begin();
                         it != fListeners->End(); ++it) {
                        (*it)->ContentCookieChanged(this, cookie);
                }
        }
}


void
KPartition::_UpdateChildIndices(int32 start, int32 end)
{
        if (start < end) {
                for (int32 i = start; i < end; i++) {
                        fChildren.ElementAt(i)->SetIndex(i);
                        fChildren.ElementAt(i)->RepublishDevice();
                }
        } else {
                for (int32 i = start; i > end; i--) {
                        fChildren.ElementAt(i)->SetIndex(i);
                        fChildren.ElementAt(i)->RepublishDevice();
                }
        }
}


int32
KPartition::_NextID()
{
        return atomic_add(&sNextID, 1);
}