LCOV - code coverage report
Current view: top level - src/backend/access/common - session.c (source / functions) Hit Total Coverage
Test: PostgreSQL 11devel Lines: 50 53 94.3 %
Date: 2017-11-22 12:18:04 Functions: 4 4 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 4 6 66.7 %

           Branch data     Line data    Source code
       1                 :            : /*-------------------------------------------------------------------------
       2                 :            :  *
       3                 :            :  * session.c
       4                 :            :  *      Encapsulation of user session.
       5                 :            :  *
       6                 :            :  * This is intended to contain data that needs to be shared between backends
       7                 :            :  * performing work for a client session.  In particular such a session is
       8                 :            :  * shared between the leader and worker processes for parallel queries.  At
       9                 :            :  * some later point it might also become useful infrastructure for separating
      10                 :            :  * backends from client connections, e.g. for the purpose of pooling.
      11                 :            :  *
      12                 :            :  * Currently this infrastructure is used to share:
      13                 :            :  * - typemod registry for ephemeral row-types, i.e. BlessTupleDesc etc.
      14                 :            :  *
      15                 :            :  * Portions Copyright (c) 2017, PostgreSQL Global Development Group
      16                 :            :  *
      17                 :            :  * src/backend/access/common/session.c
      18                 :            :  *
      19                 :            :  *-------------------------------------------------------------------------
      20                 :            :  */
      21                 :            : #include "postgres.h"
      22                 :            : 
      23                 :            : #include "access/session.h"
      24                 :            : #include "storage/lwlock.h"
      25                 :            : #include "storage/shm_toc.h"
      26                 :            : #include "utils/memutils.h"
      27                 :            : #include "utils/typcache.h"
      28                 :            : 
      29                 :            : /* Magic number for per-session DSM TOC. */
      30                 :            : #define SESSION_MAGIC                       0xabb0fbc9
      31                 :            : 
      32                 :            : /*
      33                 :            :  * We want to create a DSA area to store shared state that has the same
      34                 :            :  * lifetime as a session.  So far, it's only used to hold the shared record
      35                 :            :  * type registry.  We don't want it to have to create any DSM segments just
      36                 :            :  * yet in common cases, so we'll give it enough space to hold a very small
      37                 :            :  * SharedRecordTypmodRegistry.
      38                 :            :  */
      39                 :            : #define SESSION_DSA_SIZE                    0x30000
      40                 :            : 
      41                 :            : /*
      42                 :            :  * Magic numbers for state sharing in the per-session DSM area.
      43                 :            :  */
      44                 :            : #define SESSION_KEY_DSA                     UINT64CONST(0xFFFFFFFFFFFF0001)
      45                 :            : #define SESSION_KEY_RECORD_TYPMOD_REGISTRY  UINT64CONST(0xFFFFFFFFFFFF0002)
      46                 :            : 
      47                 :            : /* This backend's current session. */
      48                 :            : Session    *CurrentSession = NULL;
      49                 :            : 
      50                 :            : /*
      51                 :            :  * Set up CurrentSession to point to an empty Session object.
      52                 :            :  */
      53                 :            : void
      54                 :       6404 : InitializeSession(void)
      55                 :            : {
      56                 :       6404 :     CurrentSession = MemoryContextAllocZero(TopMemoryContext, sizeof(Session));
      57                 :       6404 : }
      58                 :            : 
      59                 :            : /*
      60                 :            :  * Initialize the per-session DSM segment if it isn't already initialized, and
      61                 :            :  * return its handle so that worker processes can attach to it.
      62                 :            :  *
      63                 :            :  * Unlike the per-context DSM segment, this segement and its contents are
      64                 :            :  * reused for future parallel queries.
      65                 :            :  *
      66                 :            :  * Return DSM_HANDLE_INVALID if a segment can't be allocated due to lack of
      67                 :            :  * resources.
      68                 :            :  */
      69                 :            : dsm_handle
      70                 :        120 : GetSessionDsmHandle(void)
      71                 :            : {
      72                 :            :     shm_toc_estimator estimator;
      73                 :            :     shm_toc    *toc;
      74                 :            :     dsm_segment *seg;
      75                 :            :     size_t      typmod_registry_size;
      76                 :            :     size_t      size;
      77                 :            :     void       *dsa_space;
      78                 :            :     void       *typmod_registry_space;
      79                 :            :     dsa_area   *dsa;
      80                 :            :     MemoryContext old_context;
      81                 :            : 
      82                 :            :     /*
      83                 :            :      * If we have already created a session-scope DSM segment in this backend,
      84                 :            :      * return its handle.  The same segment will be used for the rest of this
      85                 :            :      * backend's lifetime.
      86                 :            :      */
      87         [ +  + ]:        120 :     if (CurrentSession->segment != NULL)
      88                 :        112 :         return dsm_segment_handle(CurrentSession->segment);
      89                 :            : 
      90                 :            :     /* Otherwise, prepare to set one up. */
      91                 :          8 :     old_context = MemoryContextSwitchTo(TopMemoryContext);
      92                 :          8 :     shm_toc_initialize_estimator(&estimator);
      93                 :            : 
      94                 :            :     /* Estimate space for the per-session DSA area. */
      95                 :          8 :     shm_toc_estimate_keys(&estimator, 1);
      96                 :          8 :     shm_toc_estimate_chunk(&estimator, SESSION_DSA_SIZE);
      97                 :            : 
      98                 :            :     /* Estimate space for the per-session record typmod registry. */
      99                 :          8 :     typmod_registry_size = SharedRecordTypmodRegistryEstimate();
     100                 :          8 :     shm_toc_estimate_keys(&estimator, 1);
     101                 :          8 :     shm_toc_estimate_chunk(&estimator, typmod_registry_size);
     102                 :            : 
     103                 :            :     /* Set up segment and TOC. */
     104                 :          8 :     size = shm_toc_estimate(&estimator);
     105                 :          8 :     seg = dsm_create(size, DSM_CREATE_NULL_IF_MAXSEGMENTS);
     106         [ -  + ]:          8 :     if (seg == NULL)
     107                 :            :     {
     108                 :          0 :         MemoryContextSwitchTo(old_context);
     109                 :            : 
     110                 :          0 :         return DSM_HANDLE_INVALID;
     111                 :            :     }
     112                 :          8 :     toc = shm_toc_create(SESSION_MAGIC,
     113                 :            :                          dsm_segment_address(seg),
     114                 :            :                          size);
     115                 :            : 
     116                 :            :     /* Create per-session DSA area. */
     117                 :          8 :     dsa_space = shm_toc_allocate(toc, SESSION_DSA_SIZE);
     118                 :          8 :     dsa = dsa_create_in_place(dsa_space,
     119                 :            :                               SESSION_DSA_SIZE,
     120                 :            :                               LWTRANCHE_SESSION_DSA,
     121                 :            :                               seg);
     122                 :          8 :     shm_toc_insert(toc, SESSION_KEY_DSA, dsa_space);
     123                 :            : 
     124                 :            : 
     125                 :            :     /* Create session-scoped shared record typmod registry. */
     126                 :          8 :     typmod_registry_space = shm_toc_allocate(toc, typmod_registry_size);
     127                 :          8 :     SharedRecordTypmodRegistryInit((SharedRecordTypmodRegistry *)
     128                 :            :                                    typmod_registry_space, seg, dsa);
     129                 :          8 :     shm_toc_insert(toc, SESSION_KEY_RECORD_TYPMOD_REGISTRY,
     130                 :            :                    typmod_registry_space);
     131                 :            : 
     132                 :            :     /*
     133                 :            :      * If we got this far, we can pin the shared memory so it stays mapped for
     134                 :            :      * the rest of this backend's life.  If we don't make it this far, cleanup
     135                 :            :      * callbacks for anything we installed above (ie currently
     136                 :            :      * SharedRecordTypemodRegistry) will run when the DSM segment is detached
     137                 :            :      * by CurrentResourceOwner so we aren't left with a broken CurrentSession.
     138                 :            :      */
     139                 :          8 :     dsm_pin_mapping(seg);
     140                 :          8 :     dsa_pin_mapping(dsa);
     141                 :            : 
     142                 :            :     /* Make segment and area available via CurrentSession. */
     143                 :          8 :     CurrentSession->segment = seg;
     144                 :          8 :     CurrentSession->area = dsa;
     145                 :            : 
     146                 :          8 :     MemoryContextSwitchTo(old_context);
     147                 :            : 
     148                 :        120 :     return dsm_segment_handle(seg);
     149                 :            : }
     150                 :            : 
     151                 :            : /*
     152                 :            :  * Attach to a per-session DSM segment provided by a parallel leader.
     153                 :            :  */
     154                 :            : void
     155                 :        628 : AttachSession(dsm_handle handle)
     156                 :            : {
     157                 :            :     dsm_segment *seg;
     158                 :            :     shm_toc    *toc;
     159                 :            :     void       *dsa_space;
     160                 :            :     void       *typmod_registry_space;
     161                 :            :     dsa_area   *dsa;
     162                 :            :     MemoryContext old_context;
     163                 :            : 
     164                 :        628 :     old_context = MemoryContextSwitchTo(TopMemoryContext);
     165                 :            : 
     166                 :            :     /* Attach to the DSM segment. */
     167                 :        628 :     seg = dsm_attach(handle);
     168         [ -  + ]:        628 :     if (seg == NULL)
     169                 :          0 :         elog(ERROR, "could not attach to per-session DSM segment");
     170                 :        628 :     toc = shm_toc_attach(SESSION_MAGIC, dsm_segment_address(seg));
     171                 :            : 
     172                 :            :     /* Attach to the DSA area. */
     173                 :        628 :     dsa_space = shm_toc_lookup(toc, SESSION_KEY_DSA, false);
     174                 :        628 :     dsa = dsa_attach_in_place(dsa_space, seg);
     175                 :            : 
     176                 :            :     /* Make them available via the current session. */
     177                 :        628 :     CurrentSession->segment = seg;
     178                 :        628 :     CurrentSession->area = dsa;
     179                 :            : 
     180                 :            :     /* Attach to the shared record typmod registry. */
     181                 :        628 :     typmod_registry_space =
     182                 :            :         shm_toc_lookup(toc, SESSION_KEY_RECORD_TYPMOD_REGISTRY, false);
     183                 :        628 :     SharedRecordTypmodRegistryAttach((SharedRecordTypmodRegistry *)
     184                 :            :                                      typmod_registry_space);
     185                 :            : 
     186                 :            :     /* Remain attached until end of backend or DetachSession(). */
     187                 :        628 :     dsm_pin_mapping(seg);
     188                 :        628 :     dsa_pin_mapping(dsa);
     189                 :            : 
     190                 :        628 :     MemoryContextSwitchTo(old_context);
     191                 :        628 : }
     192                 :            : 
     193                 :            : /*
     194                 :            :  * Detach from the current session DSM segment.  It's not strictly necessary
     195                 :            :  * to do this explicitly since we'll detach automatically at backend exit, but
     196                 :            :  * if we ever reuse parallel workers it will become important for workers to
     197                 :            :  * detach from one session before attaching to another.  Note that this runs
     198                 :            :  * detach hooks.
     199                 :            :  */
     200                 :            : void
     201                 :        624 : DetachSession(void)
     202                 :            : {
     203                 :            :     /* Runs detach hooks. */
     204                 :        624 :     dsm_detach(CurrentSession->segment);
     205                 :        624 :     CurrentSession->segment = NULL;
     206                 :        624 :     dsa_detach(CurrentSession->area);
     207                 :        624 :     CurrentSession->area = NULL;
     208                 :        624 : }

Generated by: LCOV version 1.13