sharedfileset.h File Reference

#include "storage/dsm.h"
#include "storage/fd.h"
#include "storage/spin.h"

Include dependency graph for sharedfileset.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	SharedFileSet

Typedefs
typedef struct SharedFileSet	SharedFileSet

Functions
void	SharedFileSetInit (SharedFileSet *fileset, dsm_segment *seg)
void	SharedFileSetAttach (SharedFileSet *fileset, dsm_segment *seg)
File	SharedFileSetCreate (SharedFileSet *fileset, const char *name)
File	SharedFileSetOpen (SharedFileSet *fileset, const char *name, int mode)
bool	SharedFileSetDelete (SharedFileSet *fileset, const char *name, bool error_on_failure)
void	SharedFileSetDeleteAll (SharedFileSet *fileset)
void	SharedFileSetUnregister (SharedFileSet *input_fileset)

Typedef Documentation

SharedFileSet

typedef struct SharedFileSet SharedFileSet

Function Documentation

SharedFileSetAttach()

void SharedFileSetAttach	(	SharedFileSet *	fileset,
		dsm_segment *	seg
	)

Definition at line 127 of file sharedfileset.c.

References ereport, errcode(), errmsg(), ERROR, SharedFileSet::mutex, on_dsm_detach(), PointerGetDatum, SharedFileSet::refcnt, SharedFileSetOnDetach(), SpinLockAcquire, SpinLockRelease, and success.

Referenced by ExecHashJoinInitializeWorker(), and tuplesort_attach_shared().

{
    bool        success;

    SpinLockAcquire(&fileset->mutex);
    if (fileset->refcnt == 0)
        success = false;
    else
    {
        ++fileset->refcnt;
        success = true;
    }
    SpinLockRelease(&fileset->mutex);

    if (!success)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("could not attach to a SharedFileSet that is already destroyed")));

    /* Register our cleanup callback. */
    on_dsm_detach(seg, SharedFileSetOnDetach, PointerGetDatum(fileset));
}

SharedFileSetCreate()

File SharedFileSetCreate	(	SharedFileSet *	fileset,
		const char *	name
	)

Definition at line 154 of file sharedfileset.c.

References ChooseTablespace(), MAXPGPATH, PathNameCreateTemporaryDir(), PathNameCreateTemporaryFile(), SharedFilePath(), SharedFileSetPath(), tablespace, and TempTablespacePath().

Referenced by MakeNewSharedSegment().

{
    char        path[MAXPGPATH];
    File        file;

    SharedFilePath(path, fileset, name);
    file = PathNameCreateTemporaryFile(path, false);

    /* If we failed, see if we need to create the directory on demand. */
    if (file <= 0)
    {
        char        tempdirpath[MAXPGPATH];
        char        filesetpath[MAXPGPATH];
        Oid         tablespace = ChooseTablespace(fileset, name);

        TempTablespacePath(tempdirpath, tablespace);
        SharedFileSetPath(filesetpath, fileset, tablespace);
        PathNameCreateTemporaryDir(tempdirpath, filesetpath);
        file = PathNameCreateTemporaryFile(path, true);
    }

    return file;
}

SharedFileSetDelete()

bool SharedFileSetDelete	(	SharedFileSet *	fileset,
		const char *	name,
		bool	error_on_failure
	)

Definition at line 199 of file sharedfileset.c.

References MAXPGPATH, PathNameDeleteTemporaryFile(), and SharedFilePath().

Referenced by BufFileDeleteShared(), BufFileTruncateShared(), and MakeNewSharedSegment().

{
    char        path[MAXPGPATH];

    SharedFilePath(path, fileset, name);

    return PathNameDeleteTemporaryFile(path, error_on_failure);
}

SharedFileSetDeleteAll()

void SharedFileSetDeleteAll

(

SharedFileSet *

fileset

)

Definition at line 213 of file sharedfileset.c.

References i, MAXPGPATH, SharedFileSet::ntablespaces, PathNameDeleteTemporaryDir(), SharedFileSetPath(), SharedFileSetUnregister(), and SharedFileSet::tablespaces.

Referenced by ExecHashJoinReInitializeDSM(), SharedFileSetDeleteOnProcExit(), SharedFileSetOnDetach(), stream_cleanup_files(), and subxact_info_write().

{
    char        dirpath[MAXPGPATH];
    int         i;

    /*
     * Delete the directory we created in each tablespace.  Doesn't fail
     * because we use this in error cleanup paths, but can generate LOG
     * message on IO error.
     */
    for (i = 0; i < fileset->ntablespaces; ++i)
    {
        SharedFileSetPath(dirpath, fileset, fileset->tablespaces[i]);
        PathNameDeleteTemporaryDir(dirpath);
    }

    /* Unregister the shared fileset */
    SharedFileSetUnregister(fileset);
}

SharedFileSetInit()

void SharedFileSetInit	(	SharedFileSet *	fileset,
		dsm_segment *	seg
	)

Definition at line 64 of file sharedfileset.c.

References Assert, SharedFileSet::creator_pid, GetTempTablespaces(), i, InvalidOid, lcons(), lengthof, SharedFileSet::mutex, MyDatabaseTableSpace, MyProcPid, NIL, SharedFileSet::ntablespaces, SharedFileSet::number, on_dsm_detach(), on_proc_exit(), PointerGetDatum, PrepareTempTablespaces(), SharedFileSet::refcnt, SharedFileSetDeleteOnProcExit(), SharedFileSetOnDetach(), SpinLockInit, and SharedFileSet::tablespaces.

Referenced by ExecHashJoinInitializeDSM(), stream_open_file(), subxact_info_write(), and tuplesort_initialize_shared().

{
    static uint32 counter = 0;

    SpinLockInit(&fileset->mutex);
    fileset->refcnt = 1;
    fileset->creator_pid = MyProcPid;
    fileset->number = counter;
    counter = (counter + 1) % INT_MAX;

    /* Capture the tablespace OIDs so that all backends agree on them. */
    PrepareTempTablespaces();
    fileset->ntablespaces =
        GetTempTablespaces(&fileset->tablespaces[0],
                           lengthof(fileset->tablespaces));
    if (fileset->ntablespaces == 0)
    {
        /* If the GUC is empty, use current database's default tablespace */
        fileset->tablespaces[0] = MyDatabaseTableSpace;
        fileset->ntablespaces = 1;
    }
    else
    {
        int         i;

        /*
         * An entry of InvalidOid means use the default tablespace for the
         * current database.  Replace that now, to be sure that all users of
         * the SharedFileSet agree on what to do.
         */
        for (i = 0; i < fileset->ntablespaces; i++)
        {
            if (fileset->tablespaces[i] == InvalidOid)
                fileset->tablespaces[i] = MyDatabaseTableSpace;
        }
    }

    /* Register our cleanup callback. */
    if (seg)
        on_dsm_detach(seg, SharedFileSetOnDetach, PointerGetDatum(fileset));
    else
    {
        static bool registered_cleanup = false;

        if (!registered_cleanup)
        {
            /*
             * We must not have registered any fileset before registering the
             * fileset clean up.
             */
            Assert(filesetlist == NIL);
            on_proc_exit(SharedFileSetDeleteOnProcExit, 0);
            registered_cleanup = true;
        }

        filesetlist = lcons((void *) fileset, filesetlist);
    }
}

SharedFileSetOpen()

File SharedFileSetOpen	(	SharedFileSet *	fileset,
		const char *	name,
		int	mode
	)

Definition at line 183 of file sharedfileset.c.

References MAXPGPATH, PathNameOpenTemporaryFile(), and SharedFilePath().

Referenced by BufFileOpenShared().

{
    char        path[MAXPGPATH];
    File        file;

    SharedFilePath(path, fileset, name);
    file = PathNameOpenTemporaryFile(path, mode);

    return file;
}

SharedFileSetUnregister()

void SharedFileSetUnregister

(

SharedFileSet *

input_fileset

)

Definition at line 290 of file sharedfileset.c.

References Assert, foreach_delete_current, lfirst, and NIL.

Referenced by SharedFileSetDeleteAll().

{
    ListCell   *l;

    /*
     * If the caller is following the dsm based cleanup then we don't maintain
     * the filesetlist so return.
     */
    if (filesetlist == NIL)
        return;

    foreach(l, filesetlist)
    {
        SharedFileSet *fileset = (SharedFileSet *) lfirst(l);

        /* Remove the entry from the list */
        if (input_fileset == fileset)
        {
            filesetlist = foreach_delete_current(filesetlist, l);
            return;
        }
    }

    /* Should have found a match */
    Assert(false);
}