#include "postgres.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "access/xact.h"
#include "catalog/pg_largeobject.h"
#include "libpq/be-fsstubs.h"
#include "libpq/libpq-fs.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "storage/large_object.h"
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "utils/snapmgr.h"
#include "varatt.h"

Include dependency graph for be-fsstubs.c:

Macros
#define	BUFSIZE 8192

Functions
static int	newLOfd (void)

static void	closeLOfd (int fd)

static Oid	lo_import_internal (text *filename, Oid lobjOid)

Datum	be_lo_open (PG_FUNCTION_ARGS)

Datum	be_lo_close (PG_FUNCTION_ARGS)

int	lo_read (int fd, char *buf, int len)

int	lo_write (int fd, const char *buf, int len)

Datum	be_lo_lseek (PG_FUNCTION_ARGS)

Datum	be_lo_lseek64 (PG_FUNCTION_ARGS)

Datum	be_lo_creat (PG_FUNCTION_ARGS)

Datum	be_lo_create (PG_FUNCTION_ARGS)

Datum	be_lo_tell (PG_FUNCTION_ARGS)

Datum	be_lo_tell64 (PG_FUNCTION_ARGS)

Datum	be_lo_unlink (PG_FUNCTION_ARGS)

Datum	be_loread (PG_FUNCTION_ARGS)

Datum	be_lowrite (PG_FUNCTION_ARGS)

Datum	be_lo_import (PG_FUNCTION_ARGS)

Datum	be_lo_import_with_oid (PG_FUNCTION_ARGS)

Datum	be_lo_export (PG_FUNCTION_ARGS)

static void	lo_truncate_internal (int32 fd, int64 len)

Datum	be_lo_truncate (PG_FUNCTION_ARGS)

Datum	be_lo_truncate64 (PG_FUNCTION_ARGS)

void	AtEOXact_LargeObject (bool isCommit)

void	AtEOSubXact_LargeObject (bool isCommit, SubTransactionId mySubid, SubTransactionId parentSubid)

static bytea *	lo_get_fragment_internal (Oid loOid, int64 offset, int32 nbytes)

Datum	be_lo_get (PG_FUNCTION_ARGS)

Datum	be_lo_get_fragment (PG_FUNCTION_ARGS)

Datum	be_lo_from_bytea (PG_FUNCTION_ARGS)

Datum	be_lo_put (PG_FUNCTION_ARGS)

Variables
static LargeObjectDesc **	cookies = NULL

static int	cookies_size = 0

static bool	lo_cleanup_needed = false

static MemoryContext	fscxt = NULL

Macro Definition Documentation

◆ BUFSIZE

#define BUFSIZE 8192

Definition at line 61 of file be-fsstubs.c.

Function Documentation

◆ AtEOSubXact_LargeObject()

void AtEOSubXact_LargeObject	(	bool	isCommit,
		SubTransactionId	mySubid,
		SubTransactionId	parentSubid
	)

Definition at line 653 of file be-fsstubs.c.

{
    int         i;
 
    if (fscxt == NULL)          /* no LO operations in this xact */
        return;
 
    for (i = 0; i < cookies_size; i++)
    {
        LargeObjectDesc *lo = cookies[i];
 
        if (lo != NULL && lo->subid == mySubid)
        {
            if (isCommit)
                lo->subid = parentSubid;
            else
                closeLOfd(i);
        }
    }
}

References closeLOfd(), cookies, cookies_size, fscxt, i, and LargeObjectDesc::subid.

Referenced by AbortSubTransaction(), and CommitSubTransaction().

◆ AtEOXact_LargeObject()

void AtEOXact_LargeObject ( bool isCommit )

Definition at line 607 of file be-fsstubs.c.

{
    int         i;
 
    if (!lo_cleanup_needed)
        return;                 /* no LO operations in this xact */
 
    /*
     * Close LO fds and clear cookies array so that LO fds are no longer good.
     * The memory context and resource owner holding them are going away at
     * the end-of-transaction anyway, but on commit, we need to close them to
     * avoid warnings about leaked resources at commit.  On abort we can skip
     * this step.
     */
    if (isCommit)
    {
        for (i = 0; i < cookies_size; i++)
        {
            if (cookies[i] != NULL)
                closeLOfd(i);
        }
    }
 
    /* Needn't actually pfree since we're about to zap context */
    cookies = NULL;
    cookies_size = 0;
 
    /* Release the LO memory context to prevent permanent memory leaks. */
    if (fscxt)
        MemoryContextDelete(fscxt);
    fscxt = NULL;
 
    /* Give inv_api.c a chance to clean up, too */
    close_lo_relation(isCommit);
 
    lo_cleanup_needed = false;
}

References close_lo_relation(), closeLOfd(), cookies, cookies_size, fscxt, i, lo_cleanup_needed, and MemoryContextDelete().

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

◆ be_lo_close()

Datum be_lo_close ( PG_FUNCTION_ARGS )

Definition at line 126 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
 
#ifdef FSDB
    elog(DEBUG4, "lo_close(%d)", fd);
#endif
 
    closeLOfd(fd);
 
    PG_RETURN_INT32(0);
}

References closeLOfd(), cookies, cookies_size, DEBUG4, elog, ereport, errcode(), errmsg(), ERROR, fd(), PG_GETARG_INT32, and PG_RETURN_INT32.

◆ be_lo_creat()

Datum be_lo_creat ( PG_FUNCTION_ARGS )

Definition at line 249 of file be-fsstubs.c.

{
    Oid         lobjId;
 
    PreventCommandIfReadOnly("lo_creat()");
 
    lo_cleanup_needed = true;
    lobjId = inv_create(InvalidOid);
 
    PG_RETURN_OID(lobjId);
}

References inv_create(), InvalidOid, lo_cleanup_needed, PG_RETURN_OID, and PreventCommandIfReadOnly().

◆ be_lo_create()

Datum be_lo_create ( PG_FUNCTION_ARGS )

Definition at line 262 of file be-fsstubs.c.

{
    Oid         lobjId = PG_GETARG_OID(0);
 
    PreventCommandIfReadOnly("lo_create()");
 
    lo_cleanup_needed = true;
    lobjId = inv_create(lobjId);
 
    PG_RETURN_OID(lobjId);
}

References inv_create(), lo_cleanup_needed, PG_GETARG_OID, PG_RETURN_OID, and PreventCommandIfReadOnly().

◆ be_lo_export()

Datum be_lo_export ( PG_FUNCTION_ARGS )

Definition at line 486 of file be-fsstubs.c.

{
    Oid         lobjId = PG_GETARG_OID(0);
    text       *filename = PG_GETARG_TEXT_PP(1);
    int         fd;
    int         nbytes,
                tmp;
    char        buf[BUFSIZE];
    char        fnamebuf[MAXPGPATH];
    LargeObjectDesc *lobj;
    mode_t      oumask;
 
    /*
     * open the inversion object (no need to test for failure)
     */
    lo_cleanup_needed = true;
    lobj = inv_open(lobjId, INV_READ, CurrentMemoryContext);
 
    /*
     * open the file to be written to
     *
     * Note: we reduce backend's normal 077 umask to the slightly friendlier
     * 022. This code used to drop it all the way to 0, but creating
     * world-writable export files doesn't seem wise.
     */
    text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));
    oumask = umask(S_IWGRP | S_IWOTH);
    PG_TRY();
    {
        fd = OpenTransientFilePerm(fnamebuf, O_CREAT | O_WRONLY | O_TRUNC | PG_BINARY,
                                   S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    }
    PG_FINALLY();
    {
        umask(oumask);
    }
    PG_END_TRY();
    if (fd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create server file \"%s\": %m",
                        fnamebuf)));
 
    /*
     * read in from the inversion file and write to the filesystem
     */
    while ((nbytes = inv_read(lobj, buf, BUFSIZE)) > 0)
    {
        tmp = write(fd, buf, nbytes);
        if (tmp != nbytes)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write server file \"%s\": %m",
                            fnamebuf)));
    }
 
    if (CloseTransientFile(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m",
                        fnamebuf)));
 
    inv_close(lobj);
 
    PG_RETURN_INT32(1);
}

References buf, BUFSIZE, CloseTransientFile(), CurrentMemoryContext, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), filename, inv_close(), inv_open(), inv_read(), INV_READ, lo_cleanup_needed, MAXPGPATH, OpenTransientFilePerm(), PG_BINARY, PG_END_TRY, PG_FINALLY, PG_GETARG_OID, PG_GETARG_TEXT_PP, PG_RETURN_INT32, PG_TRY, S_IRGRP, S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR, text_to_cstring_buffer(), and write.

◆ be_lo_from_bytea()

Datum be_lo_from_bytea ( PG_FUNCTION_ARGS )

Definition at line 832 of file be-fsstubs.c.

{
    Oid         loOid = PG_GETARG_OID(0);
    bytea      *str = PG_GETARG_BYTEA_PP(1);
    LargeObjectDesc *loDesc;
    int         written PG_USED_FOR_ASSERTS_ONLY;
 
    PreventCommandIfReadOnly("lo_from_bytea()");
 
    lo_cleanup_needed = true;
    loOid = inv_create(loOid);
    loDesc = inv_open(loOid, INV_WRITE, CurrentMemoryContext);
    written = inv_write(loDesc, VARDATA_ANY(str), VARSIZE_ANY_EXHDR(str));
    Assert(written == VARSIZE_ANY_EXHDR(str));
    inv_close(loDesc);
 
    PG_RETURN_OID(loOid);
}

References Assert(), CurrentMemoryContext, inv_close(), inv_create(), inv_open(), inv_write(), INV_WRITE, lo_cleanup_needed, PG_GETARG_BYTEA_PP, PG_GETARG_OID, PG_RETURN_OID, PG_USED_FOR_ASSERTS_ONLY, PreventCommandIfReadOnly(), str, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ be_lo_get()

Datum be_lo_get ( PG_FUNCTION_ARGS )

Definition at line 797 of file be-fsstubs.c.

{
    Oid         loOid = PG_GETARG_OID(0);
    bytea      *result;
 
    result = lo_get_fragment_internal(loOid, 0, -1);
 
    PG_RETURN_BYTEA_P(result);
}

References lo_get_fragment_internal(), PG_GETARG_OID, and PG_RETURN_BYTEA_P.

◆ be_lo_get_fragment()

Datum be_lo_get_fragment ( PG_FUNCTION_ARGS )

Definition at line 811 of file be-fsstubs.c.

{
    Oid         loOid = PG_GETARG_OID(0);
    int64       offset = PG_GETARG_INT64(1);
    int32       nbytes = PG_GETARG_INT32(2);
    bytea      *result;
 
    if (nbytes < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("requested length cannot be negative")));
 
    result = lo_get_fragment_internal(loOid, offset, nbytes);
 
    PG_RETURN_BYTEA_P(result);
}

References ereport, errcode(), errmsg(), ERROR, lo_get_fragment_internal(), PG_GETARG_INT32, PG_GETARG_INT64, PG_GETARG_OID, and PG_RETURN_BYTEA_P.

◆ be_lo_import()

Datum be_lo_import ( PG_FUNCTION_ARGS )

Definition at line 403 of file be-fsstubs.c.

{
    text       *filename = PG_GETARG_TEXT_PP(0);
 
    PG_RETURN_OID(lo_import_internal(filename, InvalidOid));
}

References filename, InvalidOid, lo_import_internal(), PG_GETARG_TEXT_PP, and PG_RETURN_OID.

◆ be_lo_import_with_oid()

Datum be_lo_import_with_oid ( PG_FUNCTION_ARGS )

Definition at line 415 of file be-fsstubs.c.

{
    text       *filename = PG_GETARG_TEXT_PP(0);
    Oid         oid = PG_GETARG_OID(1);
 
    PG_RETURN_OID(lo_import_internal(filename, oid));
}

References filename, lo_import_internal(), PG_GETARG_OID, PG_GETARG_TEXT_PP, and PG_RETURN_OID.

◆ be_lo_lseek()

Datum be_lo_lseek ( PG_FUNCTION_ARGS )

Definition at line 206 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int32       offset = PG_GETARG_INT32(1);
    int32       whence = PG_GETARG_INT32(2);
    int64       status;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
 
    status = inv_seek(cookies[fd], offset, whence);
 
    /* guard against result overflow */
    if (status != (int32) status)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("lo_lseek result out of range for large-object descriptor %d",
                        fd)));
 
    PG_RETURN_INT32((int32) status);
}

References cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_seek(), PG_GETARG_INT32, and PG_RETURN_INT32.

◆ be_lo_lseek64()

Datum be_lo_lseek64 ( PG_FUNCTION_ARGS )

Definition at line 231 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int64       offset = PG_GETARG_INT64(1);
    int32       whence = PG_GETARG_INT32(2);
    int64       status;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
 
    status = inv_seek(cookies[fd], offset, whence);
 
    PG_RETURN_INT64(status);
}

References cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_seek(), PG_GETARG_INT32, PG_GETARG_INT64, and PG_RETURN_INT64.

◆ be_lo_open()

Datum be_lo_open ( PG_FUNCTION_ARGS )

Definition at line 87 of file be-fsstubs.c.

{
    Oid         lobjId = PG_GETARG_OID(0);
    int32       mode = PG_GETARG_INT32(1);
    LargeObjectDesc *lobjDesc;
    int         fd;
 
#ifdef FSDB
    elog(DEBUG4, "lo_open(%u,%d)", lobjId, mode);
#endif
 
    if (mode & INV_WRITE)
        PreventCommandIfReadOnly("lo_open(INV_WRITE)");
 
    /*
     * Allocate a large object descriptor first.  This will also create
     * 'fscxt' if this is the first LO opened in this transaction.
     */
    fd = newLOfd();
 
    lobjDesc = inv_open(lobjId, mode, fscxt);
    lobjDesc->subid = GetCurrentSubTransactionId();
 
    /*
     * We must register the snapshot in TopTransaction's resowner so that it
     * stays alive until the LO is closed rather than until the current portal
     * shuts down.
     */
    if (lobjDesc->snapshot)
        lobjDesc->snapshot = RegisterSnapshotOnOwner(lobjDesc->snapshot,
                                                     TopTransactionResourceOwner);
 
    Assert(cookies[fd] == NULL);
    cookies[fd] = lobjDesc;
 
    PG_RETURN_INT32(fd);
}

References Assert(), cookies, DEBUG4, elog, fd(), fscxt, GetCurrentSubTransactionId(), inv_open(), INV_WRITE, mode, newLOfd(), PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_INT32, PreventCommandIfReadOnly(), RegisterSnapshotOnOwner(), LargeObjectDesc::snapshot, LargeObjectDesc::subid, and TopTransactionResourceOwner.

◆ be_lo_put()

Datum be_lo_put ( PG_FUNCTION_ARGS )

Definition at line 855 of file be-fsstubs.c.

{
    Oid         loOid = PG_GETARG_OID(0);
    int64       offset = PG_GETARG_INT64(1);
    bytea      *str = PG_GETARG_BYTEA_PP(2);
    LargeObjectDesc *loDesc;
    int         written PG_USED_FOR_ASSERTS_ONLY;
 
    PreventCommandIfReadOnly("lo_put()");
 
    lo_cleanup_needed = true;
    loDesc = inv_open(loOid, INV_WRITE, CurrentMemoryContext);
    inv_seek(loDesc, offset, SEEK_SET);
    written = inv_write(loDesc, VARDATA_ANY(str), VARSIZE_ANY_EXHDR(str));
    Assert(written == VARSIZE_ANY_EXHDR(str));
    inv_close(loDesc);
 
    PG_RETURN_VOID();
}

References Assert(), CurrentMemoryContext, inv_close(), inv_open(), inv_seek(), inv_write(), INV_WRITE, lo_cleanup_needed, PG_GETARG_BYTEA_PP, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_VOID, PG_USED_FOR_ASSERTS_ONLY, PreventCommandIfReadOnly(), str, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ be_lo_tell()

Datum be_lo_tell ( PG_FUNCTION_ARGS )

Definition at line 275 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int64       offset;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
 
    offset = inv_tell(cookies[fd]);
 
    /* guard against result overflow */
    if (offset != (int32) offset)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("lo_tell result out of range for large-object descriptor %d",
                        fd)));
 
    PG_RETURN_INT32((int32) offset);
}

References cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_tell(), PG_GETARG_INT32, and PG_RETURN_INT32.

◆ be_lo_tell64()

Datum be_lo_tell64 ( PG_FUNCTION_ARGS )

Definition at line 298 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int64       offset;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
 
    offset = inv_tell(cookies[fd]);
 
    PG_RETURN_INT64(offset);
}

References cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), inv_tell(), PG_GETARG_INT32, and PG_RETURN_INT64.

◆ be_lo_truncate()

Datum be_lo_truncate ( PG_FUNCTION_ARGS )

Definition at line 579 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int32       len = PG_GETARG_INT32(1);
 
    PreventCommandIfReadOnly("lo_truncate()");
 
    lo_truncate_internal(fd, len);
    PG_RETURN_INT32(0);
}

References fd(), len, lo_truncate_internal(), PG_GETARG_INT32, PG_RETURN_INT32, and PreventCommandIfReadOnly().

◆ be_lo_truncate64()

Datum be_lo_truncate64 ( PG_FUNCTION_ARGS )

Definition at line 591 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int64       len = PG_GETARG_INT64(1);
 
    PreventCommandIfReadOnly("lo_truncate64()");
 
    lo_truncate_internal(fd, len);
    PG_RETURN_INT32(0);
}

References fd(), len, lo_truncate_internal(), PG_GETARG_INT32, PG_GETARG_INT64, PG_RETURN_INT32, and PreventCommandIfReadOnly().

◆ be_lo_unlink()

Datum be_lo_unlink ( PG_FUNCTION_ARGS )

Definition at line 314 of file be-fsstubs.c.

{
    Oid         lobjId = PG_GETARG_OID(0);
 
    PreventCommandIfReadOnly("lo_unlink()");
 
    if (!LargeObjectExists(lobjId))
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("large object %u does not exist", lobjId)));
 
    /*
     * Must be owner of the large object.  It would be cleaner to check this
     * in inv_drop(), but we want to throw the error before not after closing
     * relevant FDs.
     */
    if (!lo_compat_privileges &&
        !object_ownercheck(LargeObjectRelationId, lobjId, GetUserId()))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("must be owner of large object %u", lobjId)));
 
    /*
     * If there are any open LO FDs referencing that ID, close 'em.
     */
    if (fscxt != NULL)
    {
        int         i;
 
        for (i = 0; i < cookies_size; i++)
        {
            if (cookies[i] != NULL && cookies[i]->id == lobjId)
                closeLOfd(i);
        }
    }
 
    /*
     * inv_drop does not create a need for end-of-transaction cleanup and
     * hence we don't need to set lo_cleanup_needed.
     */
    PG_RETURN_INT32(inv_drop(lobjId));
}

References closeLOfd(), cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fscxt, GetUserId(), i, inv_drop(), LargeObjectExists(), lo_compat_privileges, object_ownercheck(), PG_GETARG_OID, PG_RETURN_INT32, and PreventCommandIfReadOnly().

Referenced by lo_manage().

◆ be_loread()

Datum be_loread ( PG_FUNCTION_ARGS )

Definition at line 362 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    int32       len = PG_GETARG_INT32(1);
    bytea      *retval;
    int         totalread;
 
    if (len < 0)
        len = 0;
 
    retval = (bytea *) palloc(VARHDRSZ + len);
    totalread = lo_read(fd, VARDATA(retval), len);
    SET_VARSIZE(retval, totalread + VARHDRSZ);
 
    PG_RETURN_BYTEA_P(retval);
}

References fd(), len, lo_read(), palloc(), PG_GETARG_INT32, PG_RETURN_BYTEA_P, SET_VARSIZE, VARDATA, and VARHDRSZ.

◆ be_lowrite()

Datum be_lowrite ( PG_FUNCTION_ARGS )

Definition at line 380 of file be-fsstubs.c.

{
    int32       fd = PG_GETARG_INT32(0);
    bytea      *wbuf = PG_GETARG_BYTEA_PP(1);
    int         bytestowrite;
    int         totalwritten;
 
    PreventCommandIfReadOnly("lowrite()");
 
    bytestowrite = VARSIZE_ANY_EXHDR(wbuf);
    totalwritten = lo_write(fd, VARDATA_ANY(wbuf), bytestowrite);
    PG_RETURN_INT32(totalwritten);
}

References fd(), lo_write(), PG_GETARG_BYTEA_PP, PG_GETARG_INT32, PG_RETURN_INT32, PreventCommandIfReadOnly(), VARDATA_ANY, and VARSIZE_ANY_EXHDR.

◆ closeLOfd()

static void closeLOfd ( int fd )

static

Definition at line 721 of file be-fsstubs.c.

{
    LargeObjectDesc *lobj;
 
    /*
     * Make sure we do not try to free twice if this errors out for some
     * reason.  Better a leak than a crash.
     */
    lobj = cookies[fd];
    cookies[fd] = NULL;
 
    if (lobj->snapshot)
        UnregisterSnapshotFromOwner(lobj->snapshot,
                                    TopTransactionResourceOwner);
    inv_close(lobj);
}

References cookies, fd(), inv_close(), LargeObjectDesc::snapshot, TopTransactionResourceOwner, and UnregisterSnapshotFromOwner().

Referenced by AtEOSubXact_LargeObject(), AtEOXact_LargeObject(), be_lo_close(), and be_lo_unlink().

◆ lo_get_fragment_internal()

static bytea * lo_get_fragment_internal	(	Oid	loOid,
		int64	offset,
		int32	nbytes
	)

static

Definition at line 746 of file be-fsstubs.c.

{
    LargeObjectDesc *loDesc;
    int64       loSize;
    int64       result_length;
    int         total_read PG_USED_FOR_ASSERTS_ONLY;
    bytea      *result = NULL;
 
    lo_cleanup_needed = true;
    loDesc = inv_open(loOid, INV_READ, CurrentMemoryContext);
 
    /*
     * Compute number of bytes we'll actually read, accommodating nbytes == -1
     * and reads beyond the end of the LO.
     */
    loSize = inv_seek(loDesc, 0, SEEK_END);
    if (loSize > offset)
    {
        if (nbytes >= 0 && nbytes <= loSize - offset)
            result_length = nbytes; /* request is wholly inside LO */
        else
            result_length = loSize - offset;    /* adjust to end of LO */
    }
    else
        result_length = 0;      /* request is wholly outside LO */
 
    /*
     * A result_length calculated from loSize may not fit in a size_t.  Check
     * that the size will satisfy this and subsequently-enforced size limits.
     */
    if (result_length > MaxAllocSize - VARHDRSZ)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("large object read request is too large")));
 
    result = (bytea *) palloc(VARHDRSZ + result_length);
 
    inv_seek(loDesc, offset, SEEK_SET);
    total_read = inv_read(loDesc, VARDATA(result), result_length);
    Assert(total_read == result_length);
    SET_VARSIZE(result, result_length + VARHDRSZ);
 
    inv_close(loDesc);
 
    return result;
}

References Assert(), CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, inv_close(), inv_open(), inv_read(), INV_READ, inv_seek(), lo_cleanup_needed, MaxAllocSize, palloc(), PG_USED_FOR_ASSERTS_ONLY, SET_VARSIZE, VARDATA, and VARHDRSZ.

Referenced by be_lo_get(), and be_lo_get_fragment().

◆ lo_import_internal()

static Oid lo_import_internal	(	text *	filename,
		Oid	lobjOid
	)

static

Definition at line 424 of file be-fsstubs.c.

{
    int         fd;
    int         nbytes,
                tmp PG_USED_FOR_ASSERTS_ONLY;
    char        buf[BUFSIZE];
    char        fnamebuf[MAXPGPATH];
    LargeObjectDesc *lobj;
    Oid         oid;
 
    PreventCommandIfReadOnly("lo_import()");
 
    /*
     * open the file to be read in
     */
    text_to_cstring_buffer(filename, fnamebuf, sizeof(fnamebuf));
    fd = OpenTransientFile(fnamebuf, O_RDONLY | PG_BINARY);
    if (fd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open server file \"%s\": %m",
                        fnamebuf)));
 
    /*
     * create an inversion object
     */
    lo_cleanup_needed = true;
    oid = inv_create(lobjOid);
 
    /*
     * read in from the filesystem and write to the inversion object
     */
    lobj = inv_open(oid, INV_WRITE, CurrentMemoryContext);
 
    while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
    {
        tmp = inv_write(lobj, buf, nbytes);
        Assert(tmp == nbytes);
    }
 
    if (nbytes < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not read server file \"%s\": %m",
                        fnamebuf)));
 
    inv_close(lobj);
 
    if (CloseTransientFile(fd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m",
                        fnamebuf)));
 
    return oid;
}

References Assert(), buf, BUFSIZE, CloseTransientFile(), CurrentMemoryContext, ereport, errcode_for_file_access(), errmsg(), ERROR, fd(), filename, inv_close(), inv_create(), inv_open(), inv_write(), INV_WRITE, lo_cleanup_needed, MAXPGPATH, OpenTransientFile(), PG_BINARY, PG_USED_FOR_ASSERTS_ONLY, PreventCommandIfReadOnly(), read, and text_to_cstring_buffer().

Referenced by be_lo_import(), and be_lo_import_with_oid().

◆ lo_read()

int lo_read	(	int	fd,
		char *	buf,
		int	len
	)

Definition at line 154 of file be-fsstubs.c.

{
    int         status;
    LargeObjectDesc *lobj;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
    lobj = cookies[fd];
 
    /*
     * Check state.  inv_read() would throw an error anyway, but we want the
     * error to be about the FD's state not the underlying privilege; it might
     * be that the privilege exists but user forgot to ask for read mode.
     */
    if ((lobj->flags & IFS_RDLOCK) == 0)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("large object descriptor %d was not opened for reading",
                        fd)));
 
    status = inv_read(lobj, buf, len);
 
    return status;
}

References buf, cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), LargeObjectDesc::flags, IFS_RDLOCK, inv_read(), and len.

Referenced by be_loread(), dumpLOs(), exportFile(), and pickout().

◆ lo_truncate_internal()

static void lo_truncate_internal	(	int32	fd,
		int64	len
	)

static

Definition at line 558 of file be-fsstubs.c.

{
    LargeObjectDesc *lobj;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
    lobj = cookies[fd];
 
    /* see comment in lo_read() */
    if ((lobj->flags & IFS_WRLOCK) == 0)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("large object descriptor %d was not opened for writing",
                        fd)));
 
    inv_truncate(lobj, len);
}

References cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), LargeObjectDesc::flags, IFS_WRLOCK, inv_truncate(), and len.

Referenced by be_lo_truncate(), and be_lo_truncate64().

◆ lo_write()

int lo_write	(	int	fd,
		const char *	buf,
		int	len
	)

Definition at line 182 of file be-fsstubs.c.

{
    int         status;
    LargeObjectDesc *lobj;
 
    if (fd < 0 || fd >= cookies_size || cookies[fd] == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_UNDEFINED_OBJECT),
                 errmsg("invalid large-object descriptor: %d", fd)));
    lobj = cookies[fd];
 
    /* see comment in lo_read() */
    if ((lobj->flags & IFS_WRLOCK) == 0)
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("large object descriptor %d was not opened for writing",
                        fd)));
 
    status = inv_write(lobj, buf, len);
 
    return status;
}

References buf, cookies, cookies_size, ereport, errcode(), errmsg(), ERROR, fd(), LargeObjectDesc::flags, IFS_WRLOCK, inv_write(), and len.

Referenced by be_lowrite(), dump_lo_buf(), importFile(), and overwrite().

◆ newLOfd()

static int newLOfd ( void )

static

Definition at line 680 of file be-fsstubs.c.

{
    int         i,
                newsize;
 
    lo_cleanup_needed = true;
    if (fscxt == NULL)
        fscxt = AllocSetContextCreate(TopMemoryContext,
                                      "Filesystem",
                                      ALLOCSET_DEFAULT_SIZES);
 
    /* Try to find a free slot */
    for (i = 0; i < cookies_size; i++)
    {
        if (cookies[i] == NULL)
            return i;
    }
 
    /* No free slot, so make the array bigger */
    if (cookies_size <= 0)
    {
        /* First time through, arbitrarily make 64-element array */
        i = 0;
        newsize = 64;
        cookies = (LargeObjectDesc **)
            MemoryContextAllocZero(fscxt, newsize * sizeof(LargeObjectDesc *));
    }
    else
    {
        /* Double size of array */
        i = cookies_size;
        newsize = cookies_size * 2;
        cookies =
            repalloc0_array(cookies, LargeObjectDesc *, cookies_size, newsize);
    }
    cookies_size = newsize;
 
    return i;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, cookies, cookies_size, fscxt, i, lo_cleanup_needed, MemoryContextAllocZero(), repalloc0_array, and TopMemoryContext.

Referenced by be_lo_open().

Variable Documentation

◆ cookies

LargeObjectDesc** cookies = NULL

static

Definition at line 71 of file be-fsstubs.c.

Referenced by AtEOSubXact_LargeObject(), AtEOXact_LargeObject(), be_lo_close(), be_lo_lseek(), be_lo_lseek64(), be_lo_open(), be_lo_tell(), be_lo_tell64(), be_lo_unlink(), closeLOfd(), lo_read(), lo_truncate_internal(), lo_write(), and newLOfd().

◆ cookies_size

int cookies_size = 0

static

Definition at line 72 of file be-fsstubs.c.

Referenced by AtEOSubXact_LargeObject(), AtEOXact_LargeObject(), be_lo_close(), be_lo_lseek(), be_lo_lseek64(), be_lo_tell(), be_lo_tell64(), be_lo_unlink(), lo_read(), lo_truncate_internal(), lo_write(), and newLOfd().

◆ fscxt

MemoryContext fscxt = NULL

static

Definition at line 75 of file be-fsstubs.c.

Referenced by AtEOSubXact_LargeObject(), AtEOXact_LargeObject(), be_lo_open(), be_lo_unlink(), and newLOfd().

◆ lo_cleanup_needed

bool lo_cleanup_needed = false

static

Definition at line 74 of file be-fsstubs.c.

Referenced by AtEOXact_LargeObject(), be_lo_creat(), be_lo_create(), be_lo_export(), be_lo_from_bytea(), be_lo_put(), lo_get_fragment_internal(), lo_import_internal(), and newLOfd().

Macros

Functions

Variables

Macro Definition Documentation

◆ BUFSIZE

Function Documentation

◆ AtEOSubXact_LargeObject()

◆ AtEOXact_LargeObject()

◆ be_lo_close()

◆ be_lo_creat()

◆ be_lo_create()

◆ be_lo_export()

◆ be_lo_from_bytea()

◆ be_lo_get()

◆ be_lo_get_fragment()

◆ be_lo_import()

◆ be_lo_import_with_oid()

◆ be_lo_lseek()

◆ be_lo_lseek64()

◆ be_lo_open()

◆ be_lo_put()

◆ be_lo_tell()

◆ be_lo_tell64()

◆ be_lo_truncate()

◆ be_lo_truncate64()

◆ be_lo_unlink()

◆ be_loread()

◆ be_lowrite()

◆ closeLOfd()

◆ lo_get_fragment_internal()

◆ lo_import_internal()

◆ lo_read()

◆ lo_truncate_internal()

◆ lo_write()

◆ newLOfd()

Variable Documentation

◆ cookies

◆ cookies_size

◆ fscxt

◆ lo_cleanup_needed