PostgreSQL Source Code: src/include/storage/dsm.h File Reference (original) (raw)

Go to the source code of this file.

◆ DSM_CREATE_NULL_IF_MAXSEGMENTS

#define DSM_CREATE_NULL_IF_MAXSEGMENTS 0x0001

Definition at line 20 of file dsm.h.

◆ dsm_segment

Definition at line 18 of file dsm.h.

◆ on_dsm_detach_callback

Definition at line 54 of file dsm.h.

◆ PGShmemHeader

Definition at line 23 of file dsm.h.

◆ cancel_on_dsm_detach()

Definition at line 1147 of file dsm.c.

1149{

1151

1153 {

1155

1158 {

1161 break;

1162 }

1163 }

1164}

static void slist_delete_current(slist_mutable_iter *iter)

#define slist_foreach_modify(iter, lhead)

#define slist_container(type, membername, ptr)

void pfree(void *pointer)

on_exit_nicely_callback function

on_dsm_detach_callback function

References dsm_segment_detach_callback::arg, arg, slist_mutable_iter::cur, dsm_segment_detach_callback::function, function, dsm_segment::on_detach, pfree(), slist_container, slist_delete_current(), and slist_foreach_modify.

Referenced by shm_mq_detach(), and test_shm_mq_setup().

◆ dsm_attach()

Definition at line 665 of file dsm.c.

666{

671

672

674

677

678

679

680

681

682

683

684

685

686

687

689 {

691 if (seg->handle == h)

692 elog(ERROR, "can't attach the same segment more than once");

693 }

694

695

698

699

703 {

704

705

706

707

708

709

710

712 continue;

713

714

716 continue;

717

718

722 {

726 }

727 break;

728 }

730

731

732

733

734

735

736

738 {

741 }

742

743

747

748 return seg;

749}

#define Assert(condition)

static void dsm_backend_startup(void)

static void * dsm_main_space_begin

void dsm_detach(dsm_segment *seg)

static dlist_head dsm_segment_list

static bool dsm_init_done

static dsm_control_header * dsm_control

static dsm_segment * dsm_create_descriptor(void)

#define INVALID_CONTROL_SLOT

static bool is_main_region_dsm_handle(dsm_handle handle)

bool dsm_impl_op(dsm_op op, dsm_handle handle, Size request_size, void **impl_private, void **mapped_address, Size *mapped_size, int elevel)

#define dlist_foreach(iter, lhead)

#define dlist_container(type, membername, ptr)

bool LWLockAcquire(LWLock *lock, LWLockMode mode)

void LWLockRelease(LWLock *lock)

References Assert, dsm_segment::control_slot, dlist_iter::cur, dlist_container, dlist_foreach, dsm_backend_startup(), dsm_control, dsm_create_descriptor(), dsm_detach(), dsm_impl_op(), dsm_init_done, dsm_main_space_begin, DSM_OP_ATTACH, dsm_segment_list, elog, ERROR, fb(), dsm_control_item::first_page, FPM_PAGE_SIZE, dsm_segment::handle, dsm_control_item::handle, i, dsm_segment::impl_private, INVALID_CONTROL_SLOT, is_main_region_dsm_handle(), IsUnderPostmaster, dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_segment::mapped_address, dsm_segment::mapped_size, dsm_control_header::nitems, nitems, dsm_control_item::npages, and dsm_control_item::refcnt.

Referenced by AttachSession(), autoprewarm_database_main(), dsa_attach(), dsa_get_total_size_from_handle(), get_segment_by_index(), GetNamedDSMSegment(), ParallelApplyWorkerMain(), ParallelWorkerMain(), and test_shm_mq_main().

◆ dsm_backend_shutdown()

◆ dsm_cleanup_using_control_segment()

Definition at line 238 of file dsm.c.

239{

240 void *mapped_address = NULL;

242 void *impl_private = NULL;

244 Size mapped_size = 0;

249

250

251

252

253

254

255

257 &mapped_address, &mapped_size, DEBUG1))

258 return;

259

260

261

262

263

266 {

268 &mapped_address, &mapped_size, LOG);

269 return;

270 }

271

272

273

274

275

278 {

281

282

284 if (refcnt == 0)

285 continue;

286

287

290 continue;

291

292

293 elog(DEBUG2, "cleaning up orphaned dynamic shared memory with ID %u (reference count %u)",

294 handle, refcnt);

295

296

299 }

300

301

303 "cleaning up dynamic shared memory control segment with ID %u",

306 &mapped_address, &mapped_size, LOG);

307}

static bool dsm_control_segment_sane(dsm_control_header *control, Size mapped_size)

References DEBUG1, DEBUG2, dsm_control_segment_sane(), dsm_impl_op(), DSM_OP_ATTACH, DSM_OP_DESTROY, DSM_OP_DETACH, elog, fb(), i, is_main_region_dsm_handle(), LOG, and nitems.

Referenced by PGSharedMemoryCreate().

◆ dsm_create()

Definition at line 516 of file dsm.c.

517{

521 size_t npages = 0;

522 size_t first_page = 0;

525

526

527

528

529

530

532

535

536

538

539

540

541

542

544 {

547 ++npages;

548

551 {

552

557

558 }

559 }

560

562 {

563

564

565

566

569 for (;;)

570 {

572

575 continue;

578 break;

579 }

581 }

582

583

586 {

588 {

590 {

594 }

595 else

598

604 return seg;

605 }

606 }

607

608

610 {

621

626 errmsg("too many dynamic shared memory segments")));

627 }

628

629

631 {

635 }

637

644

645 return seg;

646}

static void ResourceOwnerForgetDSM(ResourceOwner owner, dsm_segment *seg)

static dsm_handle make_main_region_dsm_handle(int slot)

#define DSM_CREATE_NULL_IF_MAXSEGMENTS

#define DSM_HANDLE_INVALID

int errcode(int sqlerrcode)

#define ereport(elevel,...)

bool FreePageManagerGet(FreePageManager *fpm, Size npages, Size *first_page)

void FreePageManagerPut(FreePageManager *fpm, Size first_page, Size npages)

bool IsPostmasterEnvironment

static void dlist_delete(dlist_node *node)

uint32 pg_prng_uint32(pg_prng_state *state)

pg_prng_state pg_global_prng_state

void * impl_private_pm_handle

References Assert, dsm_segment::control_slot, dlist_delete(), dsm_backend_startup(), dsm_control, dsm_create_descriptor(), DSM_CREATE_NULL_IF_MAXSEGMENTS, DSM_HANDLE_INVALID, dsm_impl_op(), dsm_init_done, dsm_main_space_begin, DSM_OP_CREATE, DSM_OP_DESTROY, ereport, errcode(), errmsg, ERROR, fb(), dsm_control_item::first_page, FPM_PAGE_SIZE, FreePageManagerGet(), FreePageManagerPut(), dsm_segment::handle, dsm_control_item::handle, i, dsm_segment::impl_private, dsm_control_item::impl_private_pm_handle, is_main_region_dsm_handle(), IsPostmasterEnvironment, IsUnderPostmaster, dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), make_main_region_dsm_handle(), dsm_segment::mapped_address, dsm_segment::mapped_size, dsm_control_header::maxitems, dsm_control_header::nitems, nitems, dsm_segment::node, dsm_control_item::npages, pfree(), pg_global_prng_state, pg_prng_uint32(), dsm_control_item::pinned, dsm_control_item::refcnt, ResourceOwnerForgetDSM(), dsm_segment::resowner, and WARNING.

Referenced by apw_load_buffers(), dsa_create_ext(), GetNamedDSMSegment(), GetSessionDsmHandle(), InitializeParallelDSM(), make_new_segment(), pa_setup_dsm(), and setup_dynamic_shared_memory().

◆ dsm_detach()

Definition at line 803 of file dsm.c.

804{

805

806

807

808

809

810

811

812

815 {

820

826

828 }

830

831

832

833

834

835

836

837

838

840 {

847 }

848

849

851 {

854

861

862

863 if (refcnt == 1)

864 {

865

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

886 {

896 }

897 }

898 }

899

900

905}

void(* on_dsm_detach_callback)(dsm_segment *, Datum arg)

static bool slist_is_empty(const slist_head *head)

static slist_node * slist_pop_head_node(slist_head *head)

#define RESUME_INTERRUPTS()

#define HOLD_INTERRUPTS()

References dsm_segment_detach_callback::arg, arg, Assert, dsm_segment::control_slot, dlist_delete(), dsm_control, dsm_impl_op(), dsm_main_space_begin, DSM_OP_DESTROY, DSM_OP_DETACH, fb(), dsm_control_item::first_page, FreePageManagerPut(), dsm_segment_detach_callback::function, function, dsm_segment::handle, dsm_control_item::handle, HOLD_INTERRUPTS, dsm_segment::impl_private, INVALID_CONTROL_SLOT, is_main_region_dsm_handle(), dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_segment::mapped_address, dsm_segment::mapped_size, dsm_segment::node, dsm_control_item::npages, dsm_segment::on_detach, pfree(), dsm_control_item::pinned, dsm_control_item::refcnt, ResourceOwnerForgetDSM(), dsm_segment::resowner, RESUME_INTERRUPTS, slist_container, slist_is_empty(), slist_pop_head_node(), and WARNING.

Referenced by apw_load_buffers(), autoprewarm_database_main(), check_for_freed_segments_locked(), destroy_superblock(), DestroyParallelContext(), DetachSession(), dsa_detach(), dsa_get_total_size_from_handle(), dsm_attach(), dsm_backend_shutdown(), dsm_detach_all(), pa_free_worker_info(), pa_shutdown(), ParallelWorkerShutdown(), ResOwnerReleaseDSM(), test_shm_mq(), test_shm_mq_main(), and test_shm_mq_pipelined().

◆ dsm_detach_all()

Definition at line 775 of file dsm.c.

776{

778

780 {

782

785 }

786

791}

static dsm_handle dsm_control_handle

static Size dsm_control_mapped_size

static void * dsm_control_impl_private

References dlist_head_element, dlist_is_empty(), dsm_control, dsm_control_handle, dsm_control_impl_private, dsm_control_mapped_size, dsm_detach(), dsm_impl_op(), DSM_OP_DETACH, dsm_segment_list, ERROR, and fb().

Referenced by postmaster_child_launch().

◆ dsm_estimate_size()

◆ dsm_find_mapping()

◆ dsm_pin_mapping()

◆ dsm_pin_segment()

Definition at line 955 of file dsm.c.

956{

957 void *handle = NULL;

958

959

960

961

962

963

964

967 elog(ERROR, "cannot pin a segment that is already pinned");

974}

void dsm_impl_pin_segment(dsm_handle handle, void *impl_private, void **impl_private_pm_handle)

References dsm_segment::control_slot, dsm_control, dsm_impl_pin_segment(), elog, ERROR, fb(), dsm_segment::handle, dsm_segment::impl_private, dsm_control_item::impl_private_pm_handle, is_main_region_dsm_handle(), dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_control_item::pinned, and dsm_control_item::refcnt.

Referenced by dsa_create_ext(), GetNamedDSMSegment(), and make_new_segment().

◆ dsm_postmaster_startup()

Definition at line 177 of file dsm.c.

178{

182

184

185

186

187

188

189

190

193

194

197 elog(DEBUG2, "dynamic shared memory system will support %u segments",

198 maxitems);

200

201

202

203

204

205

206 for (;;)

207 {

210

213 continue;

217 break;

218 }

222 "created dynamic shared memory control segment %u (%zu bytes)",

225

226

230}

static void dsm_postmaster_shutdown(int code, Datum arg)

#define PG_DYNSHMEM_CONTROL_MAGIC

static uint64 dsm_control_bytes_needed(uint32 nitems)

#define PG_DYNSHMEM_SLOTS_PER_BACKEND

#define PG_DYNSHMEM_FIXED_SLOTS

static void dsm_cleanup_for_mmap(void)

int dynamic_shared_memory_type

void on_shmem_exit(pg_on_exit_callback function, Datum arg)

static Datum PointerGetDatum(const void *X)

References Assert, DEBUG2, dsm_cleanup_for_mmap(), dsm_control, dsm_control_bytes_needed(), dsm_control_handle, dsm_control_impl_private, dsm_control_mapped_size, DSM_HANDLE_INVALID, DSM_IMPL_MMAP, dsm_impl_op(), DSM_OP_CREATE, dsm_postmaster_shutdown(), dynamic_shared_memory_type, elog, ERROR, fb(), IsUnderPostmaster, dsm_control_header::magic, MaxBackends, dsm_control_header::maxitems, dsm_control_header::nitems, on_shmem_exit(), PG_DYNSHMEM_CONTROL_MAGIC, PG_DYNSHMEM_FIXED_SLOTS, PG_DYNSHMEM_SLOTS_PER_BACKEND, pg_global_prng_state, pg_prng_uint32(), and PointerGetDatum().

Referenced by CreateSharedMemoryAndSemaphores().

◆ dsm_segment_address()

Definition at line 1095 of file dsm.c.

References Assert, fb(), and dsm_segment::mapped_address.

Referenced by apw_load_buffers(), AttachSession(), autoprewarm_database_main(), dsa_attach(), dsa_create_ext(), dsa_get_total_size_from_handle(), get_segment_by_index(), GetNamedDSMSegment(), GetSessionDsmHandle(), InitializeParallelDSM(), make_new_segment(), pa_setup_dsm(), ParallelApplyWorkerMain(), ParallelWorkerMain(), setup_dynamic_shared_memory(), and test_shm_mq_main().

◆ dsm_segment_handle()

◆ dsm_segment_map_length()

◆ dsm_shmem_init()

◆ dsm_unpin_mapping()

◆ dsm_unpin_segment()

Definition at line 988 of file dsm.c.

989{

991 bool destroy = false;

993

994

997 {

998

1000 continue;

1001

1002

1004 {

1005 control_slot = i;

1006 break;

1007 }

1008 }

1009

1010

1011

1012

1013

1014

1016 elog(ERROR, "cannot unpin unknown segment handle");

1018 elog(ERROR, "cannot unpin a segment that is not pinned");

1020

1021

1022

1023

1024

1025

1029

1030

1032 destroy = true;

1034

1035

1037

1038

1039 if (destroy)

1040 {

1044

1045

1046

1047

1048

1049

1050

1051

1052

1053

1054

1058 {

1068 }

1069 }

1070}

void dsm_impl_unpin_segment(dsm_handle handle, void **impl_private)

References Assert, dsm_control, dsm_impl_op(), dsm_impl_unpin_segment(), dsm_main_space_begin, DSM_OP_DESTROY, elog, ERROR, fb(), dsm_control_item::first_page, FreePageManagerPut(), dsm_control_item::handle, i, dsm_control_item::impl_private_pm_handle, INVALID_CONTROL_SLOT, is_main_region_dsm_handle(), dsm_control_header::item, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsm_control_header::nitems, dsm_control_item::npages, dsm_control_item::pinned, dsm_control_item::refcnt, and WARNING.

Referenced by destroy_superblock(), and dsa_release_in_place().

◆ on_dsm_detach()

Definition at line 1132 of file dsm.c.

1133{

1135

1141}

static void slist_push_head(slist_head *head, slist_node *node)

void * MemoryContextAlloc(MemoryContext context, Size size)

MemoryContext TopMemoryContext

References dsm_segment_detach_callback::arg, arg, dsm_segment_detach_callback::function, function, MemoryContextAlloc(), dsm_segment_detach_callback::node, dsm_segment::on_detach, slist_push_head(), and TopMemoryContext.

Referenced by dsa_attach(), dsa_attach_in_place(), dsa_create_ext(), dsa_create_in_place_ext(), pq_redirect_to_shm_mq(), setup_background_workers(), SharedFileSetAttach(), SharedFileSetInit(), SharedRecordTypmodRegistryAttach(), SharedRecordTypmodRegistryInit(), and shm_mq_attach().

◆ reset_on_dsm_detach()

Definition at line 1170 of file dsm.c.

1171{

1173

1175 {

1177

1178

1180 {

1183

1187 }

1188

1189

1190

1191

1192

1194 }

1195}

References dsm_segment::control_slot, dlist_iter::cur, dlist_container, dlist_foreach, dsm_segment_list, INVALID_CONTROL_SLOT, dsm_segment::on_detach, pfree(), slist_container, slist_is_empty(), and slist_pop_head_node().

Referenced by on_exit_reset().