session.c File Reference

#include "postgres.h"
#include "access/session.h"
#include "storage/lwlock.h"
#include "storage/shm_toc.h"
#include "utils/memutils.h"
#include "utils/typcache.h"

Include dependency graph for session.c:

Go to the source code of this file.

Macros
#define	SESSION_MAGIC   0xabb0fbc9
#define	SESSION_DSA_SIZE   0x30000
#define	SESSION_KEY_DSA   UINT64CONST(0xFFFFFFFFFFFF0001)
#define	SESSION_KEY_RECORD_TYPMOD_REGISTRY   UINT64CONST(0xFFFFFFFFFFFF0002)

Functions
void	InitializeSession (void)
dsm_handle	GetSessionDsmHandle (void)
void	AttachSession (dsm_handle handle)
void	DetachSession (void)

Variables
Session *	CurrentSession = NULL

Macro Definition Documentation

SESSION_DSA_SIZE

#define SESSION_DSA_SIZE   0x30000

Definition at line 39 of file session.c.

SESSION_KEY_DSA

#define SESSION_KEY_DSA   UINT64CONST(0xFFFFFFFFFFFF0001)

Definition at line 44 of file session.c.

SESSION_KEY_RECORD_TYPMOD_REGISTRY

#define SESSION_KEY_RECORD_TYPMOD_REGISTRY   UINT64CONST(0xFFFFFFFFFFFF0002)

Definition at line 45 of file session.c.

SESSION_MAGIC

#define SESSION_MAGIC   0xabb0fbc9

Definition at line 30 of file session.c.

Function Documentation

AttachSession()

void AttachSession

(

dsm_handle

handle

)

Definition at line 155 of file session.c.

{
    dsm_segment *seg;
    shm_toc    *toc;
    void       *dsa_space;
    void       *typmod_registry_space;
    dsa_area   *dsa;
    MemoryContext old_context;
 
    old_context = MemoryContextSwitchTo(TopMemoryContext);
 
    /* Attach to the DSM segment. */
    seg = dsm_attach(handle);
    if (seg == NULL)
        elog(ERROR, "could not attach to per-session DSM segment");
    toc = shm_toc_attach(SESSION_MAGIC, dsm_segment_address(seg));
 
    /* Attach to the DSA area. */
    dsa_space = shm_toc_lookup(toc, SESSION_KEY_DSA, false);
    dsa = dsa_attach_in_place(dsa_space, seg);
 
    /* Make them available via the current session. */
    CurrentSession->segment = seg;
    CurrentSession->area = dsa;
 
    /* Attach to the shared record typmod registry. */
    typmod_registry_space =
        shm_toc_lookup(toc, SESSION_KEY_RECORD_TYPMOD_REGISTRY, false);
    SharedRecordTypmodRegistryAttach((SharedRecordTypmodRegistry *)
                                     typmod_registry_space);
 
    /* Remain attached until end of backend or DetachSession(). */
    dsm_pin_mapping(seg);
    dsa_pin_mapping(dsa);
 
    MemoryContextSwitchTo(old_context);
}

References Session::area, CurrentSession, dsa_attach_in_place(), dsa_pin_mapping(), dsm_attach(), dsm_pin_mapping(), dsm_segment_address(), elog, ERROR, fb(), MemoryContextSwitchTo(), Session::segment, SESSION_KEY_DSA, SESSION_KEY_RECORD_TYPMOD_REGISTRY, SESSION_MAGIC, SharedRecordTypmodRegistryAttach(), shm_toc_attach(), shm_toc_lookup(), and TopMemoryContext.

Referenced by ParallelWorkerMain().

DetachSession()

void DetachSession

(

void

)

Definition at line 201 of file session.c.

{
    /* Runs detach hooks. */
    dsm_detach(CurrentSession->segment);
    CurrentSession->segment = NULL;
    dsa_detach(CurrentSession->area);
    CurrentSession->area = NULL;
}

References Session::area, CurrentSession, dsa_detach(), dsm_detach(), fb(), and Session::segment.

Referenced by ParallelWorkerMain().

GetSessionDsmHandle()

dsm_handle GetSessionDsmHandle

(

void

)

Definition at line 70 of file session.c.

{
    shm_toc_estimator estimator;
    shm_toc    *toc;
    dsm_segment *seg;
    size_t      typmod_registry_size;
    size_t      size;
    void       *dsa_space;
    void       *typmod_registry_space;
    dsa_area   *dsa;
    MemoryContext old_context;
 
    /*
     * If we have already created a session-scope DSM segment in this backend,
     * return its handle.  The same segment will be used for the rest of this
     * backend's lifetime.
     */
    if (CurrentSession->segment != NULL)
        return dsm_segment_handle(CurrentSession->segment);
 
    /* Otherwise, prepare to set one up. */
    old_context = MemoryContextSwitchTo(TopMemoryContext);
    shm_toc_initialize_estimator(&estimator);
 
    /* Estimate space for the per-session DSA area. */
    shm_toc_estimate_keys(&estimator, 1);
    shm_toc_estimate_chunk(&estimator, SESSION_DSA_SIZE);
 
    /* Estimate space for the per-session record typmod registry. */
    typmod_registry_size = SharedRecordTypmodRegistryEstimate();
    shm_toc_estimate_keys(&estimator, 1);
    shm_toc_estimate_chunk(&estimator, typmod_registry_size);
 
    /* Set up segment and TOC. */
    size = shm_toc_estimate(&estimator);
    seg = dsm_create(size, DSM_CREATE_NULL_IF_MAXSEGMENTS);
    if (seg == NULL)
    {
        MemoryContextSwitchTo(old_context);
 
        return DSM_HANDLE_INVALID;
    }
    toc = shm_toc_create(SESSION_MAGIC,
                         dsm_segment_address(seg),
                         size);
 
    /* Create per-session DSA area. */
    dsa_space = shm_toc_allocate(toc, SESSION_DSA_SIZE);
    dsa = dsa_create_in_place(dsa_space,
                              SESSION_DSA_SIZE,
                              LWTRANCHE_PER_SESSION_DSA,
                              seg);
    shm_toc_insert(toc, SESSION_KEY_DSA, dsa_space);
 
 
    /* Create session-scoped shared record typmod registry. */
    typmod_registry_space = shm_toc_allocate(toc, typmod_registry_size);
    SharedRecordTypmodRegistryInit((SharedRecordTypmodRegistry *)
                                   typmod_registry_space, seg, dsa);
    shm_toc_insert(toc, SESSION_KEY_RECORD_TYPMOD_REGISTRY,
                   typmod_registry_space);
 
    /*
     * If we got this far, we can pin the shared memory so it stays mapped for
     * the rest of this backend's life.  If we don't make it this far, cleanup
     * callbacks for anything we installed above (ie currently
     * SharedRecordTypmodRegistry) will run when the DSM segment is detached
     * by CurrentResourceOwner so we aren't left with a broken CurrentSession.
     */
    dsm_pin_mapping(seg);
    dsa_pin_mapping(dsa);
 
    /* Make segment and area available via CurrentSession. */
    CurrentSession->segment = seg;
    CurrentSession->area = dsa;
 
    MemoryContextSwitchTo(old_context);
 
    return dsm_segment_handle(seg);
}

References Session::area, CurrentSession, dsa_create_in_place, dsa_pin_mapping(), dsm_create(), DSM_CREATE_NULL_IF_MAXSEGMENTS, DSM_HANDLE_INVALID, dsm_pin_mapping(), dsm_segment_address(), dsm_segment_handle(), fb(), MemoryContextSwitchTo(), Session::segment, SESSION_DSA_SIZE, SESSION_KEY_DSA, SESSION_KEY_RECORD_TYPMOD_REGISTRY, SESSION_MAGIC, SharedRecordTypmodRegistryEstimate(), SharedRecordTypmodRegistryInit(), shm_toc_allocate(), shm_toc_create(), shm_toc_estimate(), shm_toc_estimate_chunk, shm_toc_estimate_keys, shm_toc_initialize_estimator, shm_toc_insert(), and TopMemoryContext.

Referenced by InitializeParallelDSM().

InitializeSession()

void InitializeSession

(

void

)

Definition at line 54 of file session.c.

{
    CurrentSession = MemoryContextAllocZero(TopMemoryContext, sizeof(Session));
}

References CurrentSession, MemoryContextAllocZero(), and TopMemoryContext.

Referenced by InitPostgres().

Variable Documentation

CurrentSession

Session* CurrentSession = NULL

Definition at line 48 of file session.c.

Referenced by AttachSession(), DetachSession(), find_or_make_matching_shared_tupledesc(), GetSessionDsmHandle(), InitializeSession(), lookup_rowtype_tupdesc_internal(), shared_record_typmod_registry_detach(), SharedRecordTypmodRegistryAttach(), and SharedRecordTypmodRegistryInit().