开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
sinvaladt.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：23k
源码类别：

数据库系统

开发平台：

Unix_Linux

sinvaladt.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * sinvaladt.c
  4.  *   POSTGRES shared cache invalidation segment definitions.
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.20 1999/05/28 17:03:28 tgl Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <stdio.h>
  15. #include <signal.h>
  16. #include <unistd.h>
  18. #include "postgres.h"
  20. #include "storage/ipc.h"
  21. #include "storage/backendid.h"
  22. #include "storage/sinvaladt.h"
  23. #include "storage/lmgr.h"
  24. #include "utils/memutils.h"
  25. #include "utils/palloc.h"
  26. #include "utils/trace.h"
  28. /* ----------------
  29.  * global variable notes
  30.  *
  31.  * SharedInvalidationSemaphore
  32.  *
  33.  * shmInvalBuffer
  34.  * the shared buffer segment, set by SISegmentAttach()
  35.  *
  36.  * MyBackendId
  37.  * might be removed later, used only for
  38.  * debugging in debug routines (end of file)
  39.  *
  40.  * SIDbId
  41.  * identification of buffer (disappears)
  42.  *
  43.  * SIRelId
  44.  * SIDummyOid   identification of buffer
  45.  * SIXidData  /
  46.  * SIXid /
  47.  *
  48.  * XXX This file really needs to be cleaned up.  We switched to using
  49.  * spinlocks to protect critical sections (as opposed to using fake
  50.  * relations and going through the lock manager) and some of the old
  51.  * cruft was 'ifdef'ed out, while other parts (now unused) are still
  52.  * compiled into the system. -mer 5/24/92
  53.  * ----------------
  54.  */
  55. #ifdef HAS_TEST_AND_SET
  56. int SharedInvalidationLockId;
  58. #else
  59. IpcSemaphoreId SharedInvalidationSemaphore;
  61. #endif
  63. SISeg    *shmInvalBuffer;
  64. extern BackendId MyBackendId;
  66. static void CleanupInvalidationState(int status, SISeg *segInOutP);
  67. static BackendId SIAssignBackendId(SISeg *segInOutP, BackendTag backendTag);
  68. static int SIGetNumEntries(SISeg *segP);
  70. /************************************************************************/
  71. /* SISetActiveProcess(segP, backendId) set the backend status active */
  72. /* should be called only by the postmaster when creating a backend */
  73. /************************************************************************/
  74. /* XXX I suspect that the segP parameter is extraneous. -hirohama */
  75. static void
  76. SISetActiveProcess(SISeg *segInOutP, BackendId backendId)
  77. {
  78. /* mark all messages as read */
  80. /* Assert(segP->procState[backendId - 1].tag == MyBackendTag); */
  82. segInOutP->procState[backendId - 1].resetState = false;
  83. segInOutP->procState[backendId - 1].limit = SIGetNumEntries(segInOutP);
  84. }
  86. /****************************************************************************/
  87. /* SIBackendInit() initializes a backend to operate on the buffer */
  88. /****************************************************************************/
  89. int
  90. SIBackendInit(SISeg *segInOutP)
  91. {
  92. LockRelId LtCreateRelId();
  93. TransactionId LMITransactionIdCopy();
  95. Assert(MyBackendTag > 0);
  97. MyBackendId = SIAssignBackendId(segInOutP, MyBackendTag);
  98. if (MyBackendId == InvalidBackendTag)
  99. return 0;
  101. #ifdef INVALIDDEBUG
  102. elog(DEBUG, "SIBackendInit: backend tag %d; backend id %d.",
  103.  MyBackendTag, MyBackendId);
  104. #endif  /* INVALIDDEBUG */
  106. SISetActiveProcess(segInOutP, MyBackendId);
  107. on_shmem_exit(CleanupInvalidationState, (caddr_t) segInOutP);
  108. return 1;
  109. }
  111. /* ----------------
  112.  * SIAssignBackendId
  113.  * ----------------
  114.  */
  115. static BackendId
  116. SIAssignBackendId(SISeg *segInOutP, BackendTag backendTag)
  117. {
  118. Index index;
  119. ProcState  *stateP = NULL;
  121. for (index = 0; index < segInOutP->maxBackends; index++)
  122. {
  123. if (segInOutP->procState[index].tag == InvalidBackendTag ||
  124. segInOutP->procState[index].tag == backendTag)
  125. {
  126. stateP = &segInOutP->procState[index];
  127. break;
  128. }
  130. if (!PointerIsValid(stateP) ||
  131. (segInOutP->procState[index].resetState &&
  132.  (!stateP->resetState ||
  133.   stateP->tag < backendTag)) ||
  134. (!stateP->resetState &&
  135.  (segInOutP->procState[index].limit <
  136.   stateP->limit ||
  137.   stateP->tag < backendTag)))
  138. stateP = &segInOutP->procState[index];
  139. }
  141. /* verify that all "procState" entries checked for matching tags */
  143. for (index++; index < segInOutP->maxBackends; index++)
  144. {
  145. if (segInOutP->procState[index].tag == backendTag)
  146. elog(FATAL, "SIAssignBackendId: tag %d found twice", backendTag);
  147. }
  149. Assert(stateP);
  151. if (stateP->tag != InvalidBackendTag)
  152. {
  153. if (stateP->tag == backendTag)
  154. elog(NOTICE, "SIAssignBackendId: reusing tag %d", backendTag);
  155. else
  156. {
  157. elog(NOTICE, "SIAssignBackendId: discarding tag %d", stateP->tag);
  158. return InvalidBackendTag;
  159. }
  160. }
  162. stateP->tag = backendTag;
  164. return 1 + stateP - &segInOutP->procState[0];
  165. }
  168. /************************************************************************/
  169. /* The following function should be called only by the postmaster !! */
  170. /************************************************************************/
  172. /************************************************************************/
  173. /* SISetDeadProcess(segP, backendId)  set the backend status DEAD */
  174. /* should be called only by the postmaster when a backend died */
  175. /************************************************************************/
  176. static void
  177. SISetDeadProcess(SISeg *segP, int backendId)
  178. {
  179. /* XXX call me.... */
  181. segP->procState[backendId - 1].resetState = false;
  182. segP->procState[backendId - 1].limit = -1;
  183. segP->procState[backendId - 1].tag = InvalidBackendTag;
  184. }
  186. /*
  187.  * CleanupInvalidationState
  188.  * Note:
  189.  * This is a temporary hack.  ExitBackend should call this instead
  190.  * of exit (via on_shmem_exit).
  191.  */
  192. static void
  193. CleanupInvalidationState(int status, /* XXX */
  194.  SISeg *segInOutP) /* XXX style */
  195. {
  196. Assert(PointerIsValid(segInOutP));
  198. SISetDeadProcess(segInOutP, MyBackendId);
  199. }
  202. /************************************************************************/
  203. /* SIComputeSize() - compute size and offsets for SI segment */
  204. /************************************************************************/
  205. static void
  206. SIComputeSize(SISegOffsets *oP, int maxBackends)
  207. {
  208. int A,
  209. B,
  210. a,
  211. b,
  212. totalSize;
  214. A = 0;
  215. /* sizeof(SISeg) includes the first ProcState entry */
  216. a = sizeof(SISeg) + sizeof(ProcState) * (maxBackends - 1);
  217. a = MAXALIGN(a); /* offset to first data entry */
  218. b = sizeof(SISegEntry) * MAXNUMMESSAGES;
  219. B = A + a + b;
  220. B = MAXALIGN(B);
  221. totalSize = B - A;
  223. oP->startSegment = A;
  224. oP->offsetToFirstEntry = a; /* relative to A */
  225. oP->offsetToEndOfSegment = totalSize; /* relative to A */
  226. }
  229. /************************************************************************/
  230. /* SISetStartEntrySection(segP, offset) - sets the offset */
  231. /************************************************************************/
  232. static void
  233. SISetStartEntrySection(SISeg *segP, Offset offset)
  234. {
  235. segP->startEntrySection = offset;
  236. }
  238. /************************************************************************/
  239. /* SIGetStartEntrySection(segP) - returnss the offset */
  240. /************************************************************************/
  241. static Offset
  242. SIGetStartEntrySection(SISeg *segP)
  243. {
  244. return segP->startEntrySection;
  245. }
  248. /************************************************************************/
  249. /* SISetEndEntrySection(segP, offset) - sets the offset */
  250. /************************************************************************/
  251. static void
  252. SISetEndEntrySection(SISeg *segP, Offset offset)
  253. {
  254. segP->endEntrySection = offset;
  255. }
  257. /************************************************************************/
  258. /* SISetEndEntryChain(segP, offset) - sets the offset */
  259. /************************************************************************/
  260. static void
  261. SISetEndEntryChain(SISeg *segP, Offset offset)
  262. {
  263. segP->endEntryChain = offset;
  264. }
  266. /************************************************************************/
  267. /* SIGetEndEntryChain(segP) - returnss the offset */
  268. /************************************************************************/
  269. static Offset
  270. SIGetEndEntryChain(SISeg *segP)
  271. {
  272. return segP->endEntryChain;
  273. }
  275. /************************************************************************/
  276. /* SISetStartEntryChain(segP, offset) - sets the offset */
  277. /************************************************************************/
  278. static void
  279. SISetStartEntryChain(SISeg *segP, Offset offset)
  280. {
  281. segP->startEntryChain = offset;
  282. }
  284. /************************************************************************/
  285. /* SIGetStartEntryChain(segP) - returns  the offset */
  286. /************************************************************************/
  287. static Offset
  288. SIGetStartEntryChain(SISeg *segP)
  289. {
  290. return segP->startEntryChain;
  291. }
  293. /************************************************************************/
  294. /* SISetNumEntries(segP, num) sets the current nuber of entries */
  295. /************************************************************************/
  296. static bool
  297. SISetNumEntries(SISeg *segP, int num)
  298. {
  299. if (num <= MAXNUMMESSAGES)
  300. {
  301. segP->numEntries = num;
  302. return true;
  303. }
  304. else
  305. {
  306. return false; /* table full */
  307. }
  308. }
  310. /************************************************************************/
  311. /* SIGetNumEntries(segP) - returns the current nuber of entries */
  312. /************************************************************************/
  313. static int
  314. SIGetNumEntries(SISeg *segP)
  315. {
  316. return segP->numEntries;
  317. }
  320. /************************************************************************/
  321. /* SISetMaxNumEntries(segP, num) sets the maximal number of entries */
  322. /************************************************************************/
  323. static bool
  324. SISetMaxNumEntries(SISeg *segP, int num)
  325. {
  326. if (num <= MAXNUMMESSAGES)
  327. {
  328. segP->maxNumEntries = num;
  329. return true;
  330. }
  331. else
  332. {
  333. return false; /* wrong number */
  334. }
  335. }
  338. /************************************************************************/
  339. /* SIGetProcStateLimit(segP, i) returns the limit of read messages */
  340. /************************************************************************/
  342. #define SIGetProcStateLimit(segP,i) 
  343. ((segP)->procState[i].limit)
  345. /************************************************************************/
  346. /* SIIncNumEntries(segP, num) increments the current nuber of entries */
  347. /************************************************************************/
  348. static bool
  349. SIIncNumEntries(SISeg *segP, int num)
  350. {
  352. /*
  353.  * Try to prevent table overflow. When the table is 70% full send a
  354.  * SIGUSR2 to the postmaster which will send it back to all the
  355.  * backends. This will be handled by Async_NotifyHandler() with a
  356.  * StartTransactionCommand() which will flush unread SI entries for
  357.  * each backend. dz - 27 Jan 1998
  358.  */
  359. if (segP->numEntries == (MAXNUMMESSAGES * 70 / 100))
  360. {
  361. TPRINTF(TRACE_VERBOSE,
  362. "SIIncNumEntries: table is 70%% full, signaling postmaster");
  363. kill(getppid(), SIGUSR2);
  364. }
  366. if ((segP->numEntries + num) <= MAXNUMMESSAGES)
  367. {
  368. segP->numEntries = segP->numEntries + num;
  369. return true;
  370. }
  371. else
  372. {
  373. return false; /* table full */
  374. }
  375. }
  377. /************************************************************************/
  378. /* SIDecNumEntries(segP, num) decrements the current nuber of entries */
  379. /************************************************************************/
  380. static bool
  381. SIDecNumEntries(SISeg *segP, int num)
  382. {
  383. if ((segP->numEntries - num) >= 0)
  384. {
  385. segP->numEntries = segP->numEntries - num;
  386. return true;
  387. }
  388. else
  389. {
  390. return false; /* not enough entries in table */
  391. }
  392. }
  394. /************************************************************************/
  395. /* SISetStartFreeSpace(segP, offset)  - sets the offset */
  396. /************************************************************************/
  397. static void
  398. SISetStartFreeSpace(SISeg *segP, Offset offset)
  399. {
  400. segP->startFreeSpace = offset;
  401. }
  403. /************************************************************************/
  404. /* SIGetStartFreeSpace(segP)  - returns the offset */
  405. /************************************************************************/
  406. static Offset
  407. SIGetStartFreeSpace(SISeg *segP)
  408. {
  409. return segP->startFreeSpace;
  410. }
  414. /************************************************************************/
  415. /* SIGetFirstDataEntry(segP)  returns first data entry */
  416. /************************************************************************/
  417. static SISegEntry *
  418. SIGetFirstDataEntry(SISeg *segP)
  419. {
  420. SISegEntry *eP;
  421. Offset startChain;
  423. startChain = SIGetStartEntryChain(segP);
  425. if (startChain == InvalidOffset)
  426. return NULL;
  428. eP = (SISegEntry *) ((Pointer) segP +
  429.  SIGetStartEntrySection(segP) +
  430.  startChain);
  431. return eP;
  432. }
  435. /************************************************************************/
  436. /* SIGetLastDataEntry(segP)  returns last data entry in the chain */
  437. /************************************************************************/
  438. static SISegEntry *
  439. SIGetLastDataEntry(SISeg *segP)
  440. {
  441. SISegEntry *eP;
  442. Offset endChain;
  444. endChain = SIGetEndEntryChain(segP);
  446. if (endChain == InvalidOffset)
  447. return NULL;
  449. eP = (SISegEntry *) ((Pointer) segP +
  450.  SIGetStartEntrySection(segP) +
  451.  endChain);
  452. return eP;
  453. }
  455. /************************************************************************/
  456. /* SIGetNextDataEntry(segP, offset)  returns next data entry */
  457. /************************************************************************/
  458. static SISegEntry *
  459. SIGetNextDataEntry(SISeg *segP, Offset offset)
  460. {
  461. SISegEntry *eP;
  463. if (offset == InvalidOffset)
  464. return NULL;
  466. eP = (SISegEntry *) ((Pointer) segP +
  467.  SIGetStartEntrySection(segP) +
  468.  offset);
  469. return eP;
  470. }
  473. /************************************************************************/
  474. /* SIGetNthDataEntry(segP, n) returns the n-th data entry in chain */
  475. /************************************************************************/
  476. static SISegEntry *
  477. SIGetNthDataEntry(SISeg *segP,
  478.   int n) /* must range from 1 to MaxMessages */
  479. {
  480. SISegEntry *eP;
  481. int i;
  483. if (n <= 0)
  484. return NULL;
  486. eP = SIGetFirstDataEntry(segP);
  487. for (i = 1; i < n; i++)
  488. {
  489. /* skip one and get the next */
  490. eP = SIGetNextDataEntry(segP, eP->next);
  491. }
  493. return eP;
  494. }
  496. /************************************************************************/
  497. /* SIEntryOffset(segP, entryP)  returns the offset for an pointer */
  498. /************************************************************************/
  499. static Offset
  500. SIEntryOffset(SISeg *segP, SISegEntry *entryP)
  501. {
  502. /* relative to B !! */
  503. return ((Offset) ((Pointer) entryP -
  504.   (Pointer) segP -
  505.   SIGetStartEntrySection(segP)));
  506. }
  509. /************************************************************************/
  510. /* SISetDataEntry(segP, data)  - sets a message in the segemnt */
  511. /************************************************************************/
  512. bool
  513. SISetDataEntry(SISeg *segP, SharedInvalidData *data)
  514. {
  515. Offset offsetToNewData;
  516. SISegEntry *eP,
  517.    *lastP;
  519. if (!SIIncNumEntries(segP, 1))
  520. return false; /* no space */
  522. /* get a free entry */
  523. offsetToNewData = SIGetStartFreeSpace(segP);
  524. eP = SIGetNextDataEntry(segP, offsetToNewData); /* it's a free one */
  525. SISetStartFreeSpace(segP, eP->next);
  526. /* fill it up */
  527. eP->entryData = *data;
  528. eP->isfree = false;
  529. eP->next = InvalidOffset;
  531. /* handle insertion point at the end of the chain !! */
  532. lastP = SIGetLastDataEntry(segP);
  533. if (lastP == NULL)
  534. {
  535. /* there is no chain, insert the first entry */
  536. SISetStartEntryChain(segP, SIEntryOffset(segP, eP));
  537. }
  538. else
  539. {
  540. /* there is a last entry in the chain */
  541. lastP->next = SIEntryOffset(segP, eP);
  542. }
  543. SISetEndEntryChain(segP, SIEntryOffset(segP, eP));
  544. return true;
  545. }
  548. /************************************************************************/
  549. /* SIDecProcLimit(segP, num)  decrements all process limits */
  550. /************************************************************************/
  551. static void
  552. SIDecProcLimit(SISeg *segP, int num)
  553. {
  554. int i;
  556. for (i = 0; i < segP->maxBackends; i++)
  557. {
  558. /* decrement only, if there is a limit > 0 */
  559. if (segP->procState[i].limit > 0)
  560. {
  561. segP->procState[i].limit = segP->procState[i].limit - num;
  562. if (segP->procState[i].limit < 0)
  563. {
  564. /* limit was not high enough, reset to zero */
  565. /* negative means it's a dead backend     */
  566. segP->procState[i].limit = 0;
  567. }
  568. }
  569. }
  570. }
  573. /************************************************************************/
  574. /* SIDelDataEntry(segP) - free the FIRST entry */
  575. /************************************************************************/
  576. bool
  577. SIDelDataEntry(SISeg *segP)
  578. {
  579. SISegEntry *e1P;
  581. if (!SIDecNumEntries(segP, 1))
  582. {
  583. /* no entries in buffer */
  584. return false;
  585. }
  587. e1P = SIGetFirstDataEntry(segP);
  588. SISetStartEntryChain(segP, e1P->next);
  589. if (SIGetStartEntryChain(segP) == InvalidOffset)
  590. {
  591. /* it was the last entry */
  592. SISetEndEntryChain(segP, InvalidOffset);
  593. }
  594. /* free the entry */
  595. e1P->isfree = true;
  596. e1P->next = SIGetStartFreeSpace(segP);
  597. SISetStartFreeSpace(segP, SIEntryOffset(segP, e1P));
  598. SIDecProcLimit(segP, 1);
  599. return true;
  600. }
  604. /************************************************************************/
  605. /* SISetProcStateInvalid(segP) checks and marks a backends state as */
  606. /* invalid */
  607. /************************************************************************/
  608. void
  609. SISetProcStateInvalid(SISeg *segP)
  610. {
  611. int i;
  613. for (i = 0; i < segP->maxBackends; i++)
  614. {
  615. if (segP->procState[i].limit == 0)
  616. {
  617. /* backend i didn't read any message                */
  618. segP->procState[i].resetState = true;
  620. /*
  621.  * XXX signal backend that it has to reset its internal cache
  622.  * ?
  623.  */
  624. }
  625. }
  626. }
  628. /************************************************************************/
  629. /* SIReadEntryData(segP, backendId, function) */
  630. /* - marks messages to be read by id */
  631. /*   and executes function */
  632. /************************************************************************/
  633. void
  634. SIReadEntryData(SISeg *segP,
  635. int backendId,
  636. void (*invalFunction) (),
  637. void (*resetFunction) ())
  638. {
  639. int i = 0;
  640. SISegEntry *data;
  642. Assert(segP->procState[backendId - 1].tag == MyBackendTag);
  644. if (!segP->procState[backendId - 1].resetState)
  645. {
  646. /* invalidate data, but only those, you have not seen yet !! */
  647. /* therefore skip read messages */
  648. data = SIGetNthDataEntry(segP,
  649.    SIGetProcStateLimit(segP, backendId - 1) + 1);
  650. while (data != NULL)
  651. {
  652. i++;
  653. segP->procState[backendId - 1].limit++; /* one more message read */
  654. invalFunction(data->entryData.cacheId,
  655.   data->entryData.hashIndex,
  656.   &data->entryData.pointerData);
  657. data = SIGetNextDataEntry(segP, data->next);
  658. }
  659. /* SIDelExpiredDataEntries(segP); */
  660. }
  661. else
  662. {
  663. /* backend must not read messages, its own state has to be reset  */
  664. elog(NOTICE, "SIReadEntryData: cache state reset");
  665. resetFunction(); /* XXXX call it here, parameters? */
  667. /* new valid state--mark all messages "read" */
  668. segP->procState[backendId - 1].resetState = false;
  669. segP->procState[backendId - 1].limit = SIGetNumEntries(segP);
  670. }
  671. /* check whether we can remove dead messages */
  672. if (i > MAXNUMMESSAGES)
  673. elog(FATAL, "SIReadEntryData: Invalid segment state");
  674. }
  676. /************************************************************************/
  677. /* SIDelExpiredDataEntries (segP) - removes irrelevant messages */
  678. /************************************************************************/
  679. void
  680. SIDelExpiredDataEntries(SISeg *segP)
  681. {
  682. int min,
  683. i,
  684. h;
  686. min = 9999999;
  687. for (i = 0; i < segP->maxBackends; i++)
  688. {
  689. h = SIGetProcStateLimit(segP, i);
  690. if (h >= 0)
  691. { /* backend active */
  692. if (h < min)
  693. min = h;
  694. }
  695. }
  696. if (min != 9999999)
  697. {
  698. /* we can remove min messages */
  699. for (i = 1; i <= min; i++)
  700. {
  701. /* this  adjusts also the state limits! */
  702. if (!SIDelDataEntry(segP))
  703. elog(FATAL, "SIDelExpiredDataEntries: Invalid segment state");
  704. }
  705. }
  706. }
  710. /************************************************************************/
  711. /* SISegInit(segP) - initializes the segment */
  712. /************************************************************************/
  713. static void
  714. SISegInit(SISeg *segP, SISegOffsets *oP, int maxBackends)
  715. {
  716. int i;
  717. SISegEntry *eP;
  719. /* set semaphore ids in the segment */
  720. /* XXX */
  721. SISetStartEntrySection(segP, oP->offsetToFirstEntry);
  722. SISetEndEntrySection(segP, oP->offsetToEndOfSegment);
  723. SISetStartFreeSpace(segP, 0);
  724. SISetStartEntryChain(segP, InvalidOffset);
  725. SISetEndEntryChain(segP, InvalidOffset);
  726. SISetNumEntries(segP, 0);
  727. SISetMaxNumEntries(segP, MAXNUMMESSAGES);
  728. segP->maxBackends = maxBackends;
  729. for (i = 0; i < segP->maxBackends; i++)
  730. {
  731. segP->procState[i].limit = -1; /* no backend active  !! */
  732. segP->procState[i].resetState = false;
  733. segP->procState[i].tag = InvalidBackendTag;
  734. }
  735. /* construct a chain of free entries */
  736. for (i = 1; i < MAXNUMMESSAGES; i++)
  737. {
  738. eP = (SISegEntry *) ((Pointer) segP +
  739.  SIGetStartEntrySection(segP) +
  740.  (i - 1) * sizeof(SISegEntry));
  741. eP->isfree = true;
  742. eP->next = i * sizeof(SISegEntry); /* relative to B */
  743. }
  744. /* handle the last free entry separate */
  745. eP = (SISegEntry *) ((Pointer) segP +
  746.  SIGetStartEntrySection(segP) +
  747.  (MAXNUMMESSAGES - 1) * sizeof(SISegEntry));
  748. eP->isfree = true;
  749. eP->next = InvalidOffset; /* it's the end of the chain !! */
  750. }
  754. /************************************************************************/
  755. /* SISegmentKill(key) - kill any segment */
  756. /************************************************************************/
  757. static void
  758. SISegmentKill(int key) /* the corresponding key for the segment */
  759. {
  760. IpcMemoryKill(key);
  761. }
  764. /************************************************************************/
  765. /* SISegmentGet(key, size) - get a shared segment of size <size> */
  766. /*   returns a segment id */
  767. /************************************************************************/
  768. static IpcMemoryId
  769. SISegmentGet(int key, /* the corresponding key for the segment */
  770.  int size, /* size of segment in bytes  */
  771.  bool create)
  772. {
  773. IpcMemoryId shmid;
  775. if (create)
  776. shmid = IpcMemoryCreate(key, size, IPCProtection);
  777. else
  778. shmid = IpcMemoryIdGet(key, size);
  779. return shmid;
  780. }
  782. /************************************************************************/
  783. /* SISegmentAttach(shmid) - attach a shared segment with id shmid */
  784. /************************************************************************/
  785. static void
  786. SISegmentAttach(IpcMemoryId shmid)
  787. {
  788. shmInvalBuffer = (struct SISeg *) IpcMemoryAttach(shmid);
  789. if (shmInvalBuffer == IpcMemAttachFailed)
  790. {
  791. /* XXX use validity function */
  792. elog(NOTICE, "SISegmentAttach: Could not attach segment");
  793. elog(FATAL, "SISegmentAttach: %m");
  794. }
  795. }
  798. /************************************************************************/
  799. /* SISegmentInit() initialize SI segment */
  800. /* */
  801. /* NB: maxBackends param is only valid when killExistingSegment is true */
  802. /************************************************************************/
  803. int
  804. SISegmentInit(bool killExistingSegment, IPCKey key, int maxBackends)
  805. {
  806. SISegOffsets offsets;
  807. IpcMemoryId shmId;
  808. bool create;
  810. if (killExistingSegment)
  811. {
  812. /* Kill existing segment */
  813. /* set semaphore */
  814. SISegmentKill(key);
  816. /* Get a shared segment */
  817. SIComputeSize(&offsets, maxBackends);
  818. create = true;
  819. shmId = SISegmentGet(key, offsets.offsetToEndOfSegment, create);
  820. if (shmId < 0)
  821. {
  822. perror("SISegmentGet: failed");
  823. return -1; /* an error */
  824. }
  826. /* Attach the shared cache invalidation  segment */
  827. /* sets the global variable shmInvalBuffer */
  828. SISegmentAttach(shmId);
  830. /* Init shared memory table */
  831. SISegInit(shmInvalBuffer, &offsets, maxBackends);
  832. }
  833. else
  834. {
  835. /* use an existing segment */
  836. create = false;
  837. shmId = SISegmentGet(key, 0, create);
  838. if (shmId < 0)
  839. {
  840. perror("SISegmentGet: getting an existent segment failed");
  841. return -1; /* an error */
  842. }
  843. /* Attach the shared cache invalidation segment */
  844. SISegmentAttach(shmId);
  845. }
  846. return 1;
  847. }