/*

 * File registry and opening functionality.

 *

 * Copyright (C) 2021 Paul Boddie <paul@boddie.org.uk>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of

 * the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA  02110-1301, USA

 */

#include "directory_resource.h"

#include "file_object_registry.h"

#include "file_pager.h"

#include <systypes/fcntl.h>

/* The file object registry provides a memory page collection to the page

   mappers it creates. */

FileObjectRegistry::FileObjectRegistry(Pages *pages)

: _pages(pages)

{

}

/* Convert opening flags to map-compatible paging flags. */

map_flags_t FileObjectRegistry::get_flags(flags_t flags)

{

    return flags & (O_WRONLY | O_RDWR) ? L4RE_DS_MAP_FLAG_RW : L4RE_DS_MAP_FLAG_RO;

}

/* Make a directory provider. */

long FileObjectRegistry::make_directory_provider(FileOpening *opening,

                                                 const char *path, flags_t flags,

                                                 fileid_t fileid,

                                                 Provider **provider)

{

    /* Make an accessor and a provider to encapsulate it. */

    DirectoryAccessor *accessor;

    long err = opening->make_directory_accessor(path, flags, fileid, &accessor);

    if (err)

        return err;

    *provider = new DirectoryProvider(accessor);

    /* Register the provider. */

    set(fileid, *provider);

    return L4_EOK;

}

/* Make a file provider. */

long FileObjectRegistry::make_file_provider(FileOpening *opening,

                                            const char *path, flags_t flags,

                                            fileid_t fileid,

                                            Provider **provider)

{

    /* Make an accessor, page mapper, and a provider to encapsulate them. */

    Accessor *accessor;

    long err = opening->make_accessor(path, flags, fileid, &accessor);

    if (err)

        return err;

    PageMapper *mapper = new PageMapper(accessor, _pages);

    *provider = new FileProvider(mapper);

    /* Register the provider. */

    set(fileid, *provider);

    return L4_EOK;

}

/* Make a provider of the appropriate type. */

long FileObjectRegistry::make_provider(FileOpening *opening,

                                       const char *path, flags_t flags,

                                       fileid_t fileid,

                                       Provider **provider)

{

    if (opening->accessing_directory(path, flags, fileid))

        return make_directory_provider(opening, path, flags, fileid, provider);

    else if (opening->accessing_file(path, flags, fileid))

        return make_file_provider(opening, path, flags, fileid, provider);

    else

        return -L4_EIO;

}

/* Return a directory resource initialised with a provider. */

long FileObjectRegistry::make_directory_resource(fileid_t fileid, offset_t *size,

                                                 object_flags_t *object_flags,

                                                 DirectoryProvider *provider,

                                                 Resource **resource)

{

    /* Provide non-file values for certain outputs. */

    *size = 0;

    *object_flags = 0;

    /* Initialise the resource with the provider and a reference to this object

       for detaching from the provider. */

    provider->attach();

    *resource = new DirectoryResource(fileid, provider, this);

    return L4_EOK;

}

/* Return a file pager initialised with a provider, page mapper and accessor. */

long FileObjectRegistry::make_file_resource(flags_t flags, fileid_t fileid,

                                            offset_t *size,

                                            object_flags_t *object_flags,

                                            FileProvider *provider,

                                            Resource **resource)

{

    /* Initialise the pager with the provider and a reference to this object for

       detaching from the provider. */

    FilePager *pager = new FilePager(fileid, provider, get_flags(flags), this);

    /* Obtain the size details from the pager, also providing appropriate

       flags. */

    *size = pager->get_data_size();

    *object_flags = OBJECT_SUPPORTS_MMAP | OBJECT_HAS_SIZE;

    provider->attach();

    *resource = pager;

    return L4_EOK;

}

/* Make a resource of the appropriate type. */

long FileObjectRegistry::make_resource(flags_t flags, fileid_t fileid,

                                       offset_t *size,

                                       object_flags_t *object_flags,

                                       Provider *provider, Resource **resource)

{

    DirectoryProvider *dp = dynamic_cast<DirectoryProvider *>(provider);

    if (dp != NULL)

        return make_directory_resource(fileid, size, object_flags, dp, resource);

    FileProvider *fp = dynamic_cast<FileProvider *>(provider);

    if (fp != NULL)

        return make_file_resource(flags, fileid, size, object_flags, fp, resource);

    return -L4_EIO;

}

/* Return a resource for a filesystem object. */

long FileObjectRegistry::get_resource(FileOpening *opening, const char *path,

                                      flags_t flags, offset_t *size,

                                      object_flags_t *object_flags,

                                      Resource **resource)

{

    std::lock_guard<std::mutex> guard(_lock);

    /* Obtain an identifier for the object, even for new files (subject to use

       of the appropriate flag). */

    fileid_t fileid;

    long err = opening->get_fileid(path, flags, &fileid);

    if (err)

        return err;

    /* Obtain a provider for the object. */

    Provider *provider;

    err = find_provider(fileid, &provider);

    /* Make a new provider if necessary. */

    if (err == -L4_ENOENT)

        err = make_provider(opening, path, flags, fileid, &provider);

    if (err)

        return err;

    /* Make a resource for the provider. */

    return make_resource(flags, fileid, size, object_flags, provider, resource);

}

/* Obtain any active provider for the given 'fileid'. */

long FileObjectRegistry::find_provider(fileid_t fileid, Provider **provider)

{

    /* Obtain any registered provider. */

    Accountable *accountable = get(fileid);

    if (accountable != NULL)

    {

        *provider = dynamic_cast<Provider *>(accountable);

        if ((*provider) != NULL)

            return L4_EOK;

        else

            return -L4_EIO;

    }

    return -L4_ENOENT;

}

// vim: tabstop=4 expandtab shiftwidth=4