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

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

数据库系统

开发平台：

Unix_Linux

md.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * md.c
  4.  *   This code manages relations that reside on magnetic disk.
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.46.2.2 1999/09/06 20:00:15 tgl Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <unistd.h>
  15. #include <fcntl.h>
  16. #include <sys/file.h>
  18. #include "postgres.h"
  20. #include "catalog/catalog.h"
  21. #include "miscadmin.h"
  22. #include "storage/smgr.h"
  24. #undef DIAGNOSTIC
  26. /*
  27.  * The magnetic disk storage manager keeps track of open file descriptors
  28.  * in its own descriptor pool.  This happens for two reasons. First, at
  29.  * transaction boundaries, we walk the list of descriptors and flush
  30.  * anything that we've dirtied in the current transaction.  Second, we want
  31.  * to support relations larger than the OS' file size limit (often 2GBytes).
  32.  * In order to do that, we break relations up into chunks of < 2GBytes
  33.  * and store one chunk in each of several files that represent the relation.
  34.  * See the BLCKSZ and RELSEG_SIZE configuration constants in include/config.h.
  35.  *
  36.  * The file descriptor stored in the relation cache (see RelationGetFile())
  37.  * is actually an index into the Md_fdvec array.  -1 indicates not open.
  38.  *
  39.  * When a relation is broken into multiple chunks, only the first chunk
  40.  * has its own entry in the Md_fdvec array; the remaining chunks have
  41.  * palloc'd MdfdVec objects that are chained onto the first chunk via the
  42.  * mdfd_chain links.  All chunks except the last MUST have size exactly
  43.  * equal to RELSEG_SIZE blocks --- see mdnblocks() and mdtruncate().
  44.  */
  46. typedef struct _MdfdVec
  47. {
  48. int mdfd_vfd; /* fd number in vfd pool */
  49. uint16 mdfd_flags; /* clean, dirty, free */
  50. int mdfd_lstbcnt; /* most recent block count */
  51. int mdfd_nextFree; /* next free vector */
  52. #ifndef LET_OS_MANAGE_FILESIZE
  53. struct _MdfdVec *mdfd_chain;/* for large relations */
  54. #endif
  55. } MdfdVec;
  57. static int Nfds = 100; /* initial/current size of Md_fdvec array */
  58. static MdfdVec *Md_fdvec = (MdfdVec *) NULL;
  59. static int Md_Free = -1; /* head of freelist of unused fdvec entries */
  60. static int CurFd = 0; /* first never-used fdvec index */
  61. static MemoryContext MdCxt; /* context for all my allocations */
  63. #define MDFD_DIRTY (uint16) 0x01
  64. #define MDFD_FREE (uint16) 0x02
  66. /* routines declared here */
  67. static int _mdfd_getrelnfd(Relation reln);
  68. static MdfdVec *_mdfd_openseg(Relation reln, int segno, int oflags);
  69. static MdfdVec *_mdfd_getseg(Relation reln, int blkno);
  70. static int _fdvec_alloc(void);
  71. static void _fdvec_free(int);
  72. static BlockNumber _mdnblocks(File file, Size blcksz);
  74. /*
  75.  * mdinit() -- Initialize private state for magnetic disk storage manager.
  76.  *
  77.  * We keep a private table of all file descriptors.  Whenever we do
  78.  * a write to one, we mark it dirty in our table. Whenever we force
  79.  * changes to disk, we mark the file descriptor clean.  At transaction
  80.  * commit, we force changes to disk for all dirty file descriptors.
  81.  * This routine allocates and initializes the table.
  82.  *
  83.  * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
  84.  */
  85. int
  86. mdinit()
  87. {
  88. MemoryContext oldcxt;
  89. int i;
  91. MdCxt = (MemoryContext) CreateGlobalMemory("MdSmgr");
  92. if (MdCxt == (MemoryContext) NULL)
  93. return SM_FAIL;
  95. oldcxt = MemoryContextSwitchTo(MdCxt);
  96. Md_fdvec = (MdfdVec *) palloc(Nfds * sizeof(MdfdVec));
  97. MemoryContextSwitchTo(oldcxt);
  99. if (Md_fdvec == (MdfdVec *) NULL)
  100. return SM_FAIL;
  102. MemSet(Md_fdvec, 0, Nfds * sizeof(MdfdVec));
  104. /* Set free list */
  105. for (i = 0; i < Nfds; i++)
  106. {
  107. Md_fdvec[i].mdfd_nextFree = i + 1;
  108. Md_fdvec[i].mdfd_flags = MDFD_FREE;
  109. }
  110. Md_Free = 0;
  111. Md_fdvec[Nfds - 1].mdfd_nextFree = -1;
  113. return SM_SUCCESS;
  114. }
  116. int
  117. mdcreate(Relation reln)
  118. {
  119. int fd,
  120. vfd;
  121. char    *path;
  123. path = relpath(reln->rd_rel->relname.data);
  124. #ifndef __CYGWIN32__
  125. fd = FileNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL, 0600);
  126. #else
  127. fd = FileNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
  128. #endif
  130. /*
  131.  * If the file already exists and is empty, we pretend that the create
  132.  * succeeded.  During bootstrap processing, we skip that check,
  133.  * because pg_time, pg_variable, and pg_log get created before their
  134.  * .bki file entries are processed.
  135.  *
  136.  * As the result of this pretence it was possible to have in pg_class > 1
  137.  * records with the same relname. Actually, it should be fixed in
  138.  * upper levels, too, but... - vadim 05/06/97
  139.  */
  141. if (fd < 0)
  142. {
  143. if (!IsBootstrapProcessingMode())
  144. return -1;
  145. #ifndef __CYGWIN32__
  146. fd = FileNameOpenFile(path, O_RDWR, 0600); /* Bootstrap */
  147. #else
  148. fd = FileNameOpenFile(path, O_RDWR | O_BINARY, 0600); /* Bootstrap */
  149. #endif
  150. if (fd < 0)
  151. return -1;
  152. }
  154. vfd = _fdvec_alloc();
  155. if (vfd < 0)
  156. return -1;
  158. Md_fdvec[vfd].mdfd_vfd = fd;
  159. Md_fdvec[vfd].mdfd_flags = (uint16) 0;
  160. #ifndef LET_OS_MANAGE_FILESIZE
  161. Md_fdvec[vfd].mdfd_chain = (MdfdVec *) NULL;
  162. #endif
  163. Md_fdvec[vfd].mdfd_lstbcnt = 0;
  165. return vfd;
  166. }
  168. /*
  169.  * mdunlink() -- Unlink a relation.
  170.  */
  171. int
  172. mdunlink(Relation reln)
  173. {
  174. int nblocks;
  175. int fd;
  176. MdfdVec    *v;
  177. MemoryContext oldcxt;
  179. /*
  180.  * Force all segments of the relation to be opened, so that we
  181.  * won't miss deleting any of them.
  182.  */
  183. nblocks = mdnblocks(reln);
  185. /*
  186.  * Clean out the mdfd vector, letting fd.c unlink the physical files.
  187.  *
  188.  * NOTE: We truncate the file(s) before deleting 'em, because if other
  189.  * backends are holding the files open, the unlink will fail on some
  190.  * platforms (think Microsoft).  Better a zero-size file gets left around
  191.  * than a big file.  Those other backends will be forced to close the
  192.  * relation by cache invalidation, but that probably hasn't happened yet.
  193.  */
  194. fd = RelationGetFile(reln);
  195. if (fd < 0) /* should not happen */
  196. elog(ERROR, "mdunlink: mdnblocks didn't open relation");
  198. Md_fdvec[fd].mdfd_flags = (uint16) 0;
  200. oldcxt = MemoryContextSwitchTo(MdCxt);
  201. #ifndef LET_OS_MANAGE_FILESIZE
  202. for (v = &Md_fdvec[fd]; v != (MdfdVec *) NULL;)
  203. {
  204. MdfdVec    *ov = v;
  205. FileTruncate(v->mdfd_vfd, 0);
  206. FileUnlink(v->mdfd_vfd);
  207. v = v->mdfd_chain;
  208. if (ov != &Md_fdvec[fd])
  209. pfree(ov);
  210. }
  211. Md_fdvec[fd].mdfd_chain = (MdfdVec *) NULL;
  212. #else
  213. v = &Md_fdvec[fd];
  214. FileTruncate(v->mdfd_vfd, 0);
  215. FileUnlink(v->mdfd_vfd);
  216. #endif
  217. MemoryContextSwitchTo(oldcxt);
  219. _fdvec_free(fd);
  221. /* be sure to mark relation closed */
  222. reln->rd_fd = -1;
  224. return SM_SUCCESS;
  225. }
  227. /*
  228.  * mdextend() -- Add a block to the specified relation.
  229.  *
  230.  * This routine returns SM_FAIL or SM_SUCCESS, with errno set as
  231.  * appropriate.
  232.  */
  233. int
  234. mdextend(Relation reln, char *buffer)
  235. {
  236. long pos;
  237. int nblocks;
  238. MdfdVec    *v;
  240. nblocks = mdnblocks(reln);
  241. v = _mdfd_getseg(reln, nblocks);
  243. if ((pos = FileSeek(v->mdfd_vfd, 0L, SEEK_END)) < 0)
  244. return SM_FAIL;
  246. if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ)
  247. return SM_FAIL;
  249. /* remember that we did a write, so we can sync at xact commit */
  250. v->mdfd_flags |= MDFD_DIRTY;
  252. /* try to keep the last block count current, though it's just a hint */
  253. #ifndef LET_OS_MANAGE_FILESIZE
  254. if ((v->mdfd_lstbcnt = (++nblocks % RELSEG_SIZE)) == 0)
  255. v->mdfd_lstbcnt = RELSEG_SIZE;
  257. #ifdef DIAGNOSTIC
  258. if (_mdnblocks(v->mdfd_vfd, BLCKSZ) > RELSEG_SIZE
  259. || v->mdfd_lstbcnt > RELSEG_SIZE)
  260. elog(FATAL, "segment too big!");
  261. #endif
  262. #else
  263. v->mdfd_lstbcnt = ++nblocks;
  264. #endif
  266. return SM_SUCCESS;
  267. }
  269. /*
  270.  * mdopen() -- Open the specified relation.
  271.  */
  272. int
  273. mdopen(Relation reln)
  274. {
  275. char    *path;
  276. int fd;
  277. int vfd;
  279. path = relpath(reln->rd_rel->relname.data);
  281. #ifndef __CYGWIN32__
  282. fd = FileNameOpenFile(path, O_RDWR, 0600);
  283. #else
  284. fd = FileNameOpenFile(path, O_RDWR | O_BINARY, 0600);
  285. #endif
  287. if (fd < 0)
  288. {
  289. /* in bootstrap mode, accept mdopen as substitute for mdcreate */
  290. if (IsBootstrapProcessingMode())
  291. {
  292. #ifndef __CYGWIN32__
  293. fd = FileNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL, 0600);
  294. #else
  295. fd = FileNameOpenFile(path, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
  296. #endif
  297. }
  298. if (fd < 0)
  299. {
  300. elog(ERROR, "mdopen: couldn't open %s: %m", path);
  301. return -1;
  302. }
  303. }
  305. vfd = _fdvec_alloc();
  306. if (vfd < 0)
  307. return -1;
  309. Md_fdvec[vfd].mdfd_vfd = fd;
  310. Md_fdvec[vfd].mdfd_flags = (uint16) 0;
  311. Md_fdvec[vfd].mdfd_lstbcnt = _mdnblocks(fd, BLCKSZ);
  312. #ifndef LET_OS_MANAGE_FILESIZE
  313. Md_fdvec[vfd].mdfd_chain = (MdfdVec *) NULL;
  315. #ifdef DIAGNOSTIC
  316. if (Md_fdvec[vfd].mdfd_lstbcnt > RELSEG_SIZE)
  317. elog(FATAL, "segment too big on relopen!");
  318. #endif
  319. #endif
  321. return vfd;
  322. }
  324. /*
  325.  * mdclose() -- Close the specified relation, if it isn't closed already.
  326.  *
  327.  * AND FREE fd vector! It may be re-used for other relation!
  328.  * reln should be flushed from cache after closing !..
  329.  *
  330.  * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
  331.  */
  332. int
  333. mdclose(Relation reln)
  334. {
  335. int fd;
  336. MdfdVec    *v;
  337. MemoryContext oldcxt;
  339. fd = RelationGetFile(reln);
  340. if (fd < 0)
  341. return SM_SUCCESS; /* already closed, so no work */
  343. oldcxt = MemoryContextSwitchTo(MdCxt);
  344. #ifndef LET_OS_MANAGE_FILESIZE
  345. for (v = &Md_fdvec[fd]; v != (MdfdVec *) NULL;)
  346. {
  347. MdfdVec    *ov = v;
  349. /* if not closed already */
  350. if (v->mdfd_vfd >= 0)
  351. {
  353. /*
  354.  * We sync the file descriptor so that we don't need to reopen
  355.  * it at transaction commit to force changes to disk.
  356.  */
  358. FileSync(v->mdfd_vfd);
  359. FileClose(v->mdfd_vfd);
  361. /* mark this file descriptor as clean in our private table */
  362. v->mdfd_flags &= ~MDFD_DIRTY;
  363. }
  364. /* Now free vector */
  365. v = v->mdfd_chain;
  366. if (ov != &Md_fdvec[fd])
  367. pfree(ov);
  368. }
  370. Md_fdvec[fd].mdfd_chain = (MdfdVec *) NULL;
  371. #else
  372. v = &Md_fdvec[fd];
  373. if (v != (MdfdVec *) NULL)
  374. {
  375. if (v->mdfd_vfd >= 0)
  376. {
  378. /*
  379.  * We sync the file descriptor so that we don't need to reopen
  380.  * it at transaction commit to force changes to disk.
  381.  */
  383. FileSync(v->mdfd_vfd);
  384. FileClose(v->mdfd_vfd);
  386. /* mark this file descriptor as clean in our private table */
  387. v->mdfd_flags &= ~MDFD_DIRTY;
  388. }
  389. }
  390. #endif
  391. MemoryContextSwitchTo(oldcxt);
  393. _fdvec_free(fd);
  395. /* be sure to mark relation closed */
  396. reln->rd_fd = -1;
  398. return SM_SUCCESS;
  399. }
  401. /*
  402.  * mdread() -- Read the specified block from a relation.
  403.  *
  404.  * Returns SM_SUCCESS or SM_FAIL.
  405.  */
  406. int
  407. mdread(Relation reln, BlockNumber blocknum, char *buffer)
  408. {
  409. int status;
  410. long seekpos;
  411. int nbytes;
  412. MdfdVec    *v;
  414. v = _mdfd_getseg(reln, blocknum);
  416. #ifndef LET_OS_MANAGE_FILESIZE
  417. seekpos = (long) (BLCKSZ * (blocknum % RELSEG_SIZE));
  419. #ifdef DIAGNOSTIC
  420. if (seekpos >= BLCKSZ * RELSEG_SIZE)
  421. elog(FATAL, "seekpos too big!");
  422. #endif
  423. #else
  424. seekpos = (long) (BLCKSZ * (blocknum));
  425. #endif
  427. if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
  428. return SM_FAIL;
  430. status = SM_SUCCESS;
  431. if ((nbytes = FileRead(v->mdfd_vfd, buffer, BLCKSZ)) != BLCKSZ)
  432. {
  433. if (nbytes == 0)
  434. MemSet(buffer, 0, BLCKSZ);
  435. else
  436. status = SM_FAIL;
  437. }
  439. return status;
  440. }
  442. /*
  443.  * mdwrite() -- Write the supplied block at the appropriate location.
  444.  *
  445.  * Returns SM_SUCCESS or SM_FAIL.
  446.  */
  447. int
  448. mdwrite(Relation reln, BlockNumber blocknum, char *buffer)
  449. {
  450. int status;
  451. long seekpos;
  452. MdfdVec    *v;
  454. v = _mdfd_getseg(reln, blocknum);
  456. #ifndef LET_OS_MANAGE_FILESIZE
  457. seekpos = (long) (BLCKSZ * (blocknum % RELSEG_SIZE));
  458. #ifdef DIAGNOSTIC
  459. if (seekpos >= BLCKSZ * RELSEG_SIZE)
  460. elog(FATAL, "seekpos too big!");
  461. #endif
  462. #else
  463. seekpos = (long) (BLCKSZ * (blocknum));
  464. #endif
  466. if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
  467. return SM_FAIL;
  469. status = SM_SUCCESS;
  470. if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ)
  471. status = SM_FAIL;
  473. v->mdfd_flags |= MDFD_DIRTY;
  475. return status;
  476. }
  478. /*
  479.  * mdflush() -- Synchronously write a block to disk.
  480.  *
  481.  * This is exactly like mdwrite(), but doesn't return until the file
  482.  * system buffer cache has been flushed.
  483.  */
  484. int
  485. mdflush(Relation reln, BlockNumber blocknum, char *buffer)
  486. {
  487. int status;
  488. long seekpos;
  489. MdfdVec    *v;
  491. v = _mdfd_getseg(reln, blocknum);
  493. #ifndef LET_OS_MANAGE_FILESIZE
  494. seekpos = (long) (BLCKSZ * (blocknum % RELSEG_SIZE));
  495. #ifdef DIAGNOSTIC
  496. if (seekpos >= BLCKSZ * RELSEG_SIZE)
  497. elog(FATAL, "seekpos too big!");
  498. #endif
  499. #else
  500. seekpos = (long) (BLCKSZ * (blocknum));
  501. #endif
  503. if (FileSeek(v->mdfd_vfd, seekpos, SEEK_SET) != seekpos)
  504. return SM_FAIL;
  506. /* write and sync the block */
  507. status = SM_SUCCESS;
  508. if (FileWrite(v->mdfd_vfd, buffer, BLCKSZ) != BLCKSZ
  509. || FileSync(v->mdfd_vfd) < 0)
  510. status = SM_FAIL;
  512. /*
  513.  * By here, the block is written and changes have been forced to
  514.  * stable storage. Mark the descriptor as clean until the next write,
  515.  * so we don't sync it again unnecessarily at transaction commit.
  516.  */
  518. v->mdfd_flags &= ~MDFD_DIRTY;
  520. return status;
  521. }
  523. /*
  524.  * mdblindwrt() -- Write a block to disk blind.
  525.  *
  526.  * We have to be able to do this using only the name and OID of
  527.  * the database and relation in which the block belongs.  This
  528.  * is a synchronous write.
  529.  */
  530. int
  531. mdblindwrt(char *dbstr,
  532.    char *relstr,
  533.    Oid dbid,
  534.    Oid relid,
  535.    BlockNumber blkno,
  536.    char *buffer)
  537. {
  538. int fd;
  539. int segno;
  540. long seekpos;
  541. int status;
  542. char    *path;
  544. #ifndef LET_OS_MANAGE_FILESIZE
  545. int nchars;
  547. /* be sure we have enough space for the '.segno', if any */
  548. segno = blkno / RELSEG_SIZE;
  549. if (segno > 0)
  550. nchars = 10;
  551. else
  552. nchars = 0;
  554. /* construct the path to the file and open it */
  555. /* system table? then put in system area... */
  556. if (dbid == (Oid) 0)
  557. {
  558. path = (char *) palloc(strlen(DataDir) + sizeof(NameData) + 2 + nchars);
  559. if (segno == 0)
  560. sprintf(path, "%s/%s", DataDir, relstr);
  561. else
  562. sprintf(path, "%s/%s.%d", DataDir, relstr, segno);
  563. }
  564. /* user table? then put in user database area... */
  565. else if (dbid == MyDatabaseId)
  566. {
  567. extern char *DatabasePath;
  569. path = (char *) palloc(strlen(DatabasePath) + 2 * sizeof(NameData) + 2 + nchars);
  570. if (segno == 0)
  571. sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relstr);
  572. else
  573. sprintf(path, "%s%c%s.%d", DatabasePath, SEP_CHAR, relstr, segno);
  574. }
  575. else
  576. /* this is work arround only !!! */
  577. {
  578. char dbpath[MAXPGPATH + 1];
  579. int4 owner;
  580. Oid id;
  581. char    *tmpPath;
  582. int tmpEncoding;
  584. GetRawDatabaseInfo(dbstr, &owner, &id, dbpath, &tmpEncoding);
  586. if (id != dbid)
  587. elog(FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
  588. tmpPath = ExpandDatabasePath(dbpath);
  589. if (tmpPath == NULL)
  590. elog(FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
  591. path = (char *) palloc(strlen(tmpPath) + 2 * sizeof(NameData) + 2 + nchars);
  592. if (segno == 0)
  593. sprintf(path, "%s%c%s", tmpPath, SEP_CHAR, relstr);
  594. else
  595. sprintf(path, "%s%c%s.%d", tmpPath, SEP_CHAR, relstr, segno);
  596. pfree(tmpPath);
  597. }
  598. #else
  599. /* construct the path to the file and open it */
  600. /* system table? then put in system area... */
  601. if (dbid == (Oid) 0)
  602. {
  603. path = (char *) palloc(strlen(DataDir) + sizeof(NameData) + 2);
  604. sprintf(path, "%s/%s", DataDir, relstr);
  605. }
  606. /* user table? then put in user database area... */
  607. else if (dbid == MyDatabaseId)
  608. {
  609. extern char *DatabasePath;
  611. path = (char *) palloc(strlen(DatabasePath) + 2 * sizeof(NameData) + 2);
  612. sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relstr);
  613. }
  614. else
  615. /* this is work arround only !!! */
  616. {
  617. char dbpath[MAXPGPATH + 1];
  618. int4 owner;
  619. Oid id;
  620. char    *tmpPath;
  621. int tmpEncoding;
  623. GetRawDatabaseInfo(dbstr, &owner, &id, dbpath, &tmpEncoding);
  625. if (id != dbid)
  626. elog(FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
  627. tmpPath = ExpandDatabasePath(dbpath);
  628. if (tmpPath == NULL)
  629. elog(FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
  630. path = (char *) palloc(strlen(tmpPath) + 2 * sizeof(NameData) + 2);
  631. sprintf(path, "%s%c%s", tmpPath, SEP_CHAR, relstr);
  632. pfree(tmpPath);
  633. }
  634. #endif
  636. #ifndef __CYGWIN32__
  637. if ((fd = open(path, O_RDWR, 0600)) < 0)
  638. #else
  639. if ((fd = open(path, O_RDWR | O_BINARY, 0600)) < 0)
  640. #endif
  641. return SM_FAIL;
  643. /* seek to the right spot */
  644. #ifndef LET_OS_MANAGE_FILESIZE
  645. seekpos = (long) (BLCKSZ * (blkno % RELSEG_SIZE));
  646. #else
  647. seekpos = (long) (BLCKSZ * (blkno));
  648. #endif
  650. if (lseek(fd, seekpos, SEEK_SET) != seekpos)
  651. {
  652. close(fd);
  653. return SM_FAIL;
  654. }
  656. status = SM_SUCCESS;
  658. /* write and sync the block */
  659. if (write(fd, buffer, BLCKSZ) != BLCKSZ || (pg_fsync(fd) < 0))
  660. status = SM_FAIL;
  662. if (close(fd) < 0)
  663. status = SM_FAIL;
  665. pfree(path);
  667. return status;
  668. }
  670. /*
  671.  * mdnblocks() -- Get the number of blocks stored in a relation.
  672.  *
  673.  * Important side effect: all segments of the relation are opened
  674.  * and added to the mdfd_chain list.  If this routine has not been
  675.  * called, then only segments up to the last one actually touched
  676.  * are present in the chain...
  677.  *
  678.  * Returns # of blocks, elog's on error.
  679.  */
  680. int
  681. mdnblocks(Relation reln)
  682. {
  683. int fd;
  684. MdfdVec    *v;
  685. #ifndef LET_OS_MANAGE_FILESIZE
  686. int nblocks;
  687. int segno;
  688. #endif
  690. fd = _mdfd_getrelnfd(reln);
  691. v = &Md_fdvec[fd];
  693. #ifndef LET_OS_MANAGE_FILESIZE
  694. segno = 0;
  695. for (;;)
  696. {
  697. nblocks = _mdnblocks(v->mdfd_vfd, BLCKSZ);
  698. if (nblocks > RELSEG_SIZE)
  699. elog(FATAL, "segment too big in mdnblocks!");
  700. v->mdfd_lstbcnt = nblocks;
  701. if (nblocks == RELSEG_SIZE)
  702. {
  703. segno++;
  705. if (v->mdfd_chain == (MdfdVec *) NULL)
  706. {
  707. v->mdfd_chain = _mdfd_openseg(reln, segno, O_CREAT);
  708. if (v->mdfd_chain == (MdfdVec *) NULL)
  709. elog(ERROR, "cannot count blocks for %s -- open failed",
  710.  RelationGetRelationName(reln));
  711. }
  713. v = v->mdfd_chain;
  714. }
  715. else
  716. return (segno * RELSEG_SIZE) + nblocks;
  717. }
  718. #else
  719. return _mdnblocks(v->mdfd_vfd, BLCKSZ);
  720. #endif
  721. }
  723. /*
  724.  * mdtruncate() -- Truncate relation to specified number of blocks.
  725.  *
  726.  * Returns # of blocks or -1 on error.
  727.  */
  728. int
  729. mdtruncate(Relation reln, int nblocks)
  730. {
  731. int curnblk;
  732. int fd;
  733. MdfdVec    *v;
  734. #ifndef LET_OS_MANAGE_FILESIZE
  735. MemoryContext oldcxt;
  736. int priorblocks;
  737. #endif
  739. /* NOTE: mdnblocks makes sure we have opened all existing segments,
  740.  * so that truncate/delete loop will get them all!
  741.  */
  742. curnblk = mdnblocks(reln);
  743. if (nblocks < 0 || nblocks > curnblk)
  744. return -1; /* bogus request */
  745. if (nblocks == curnblk)
  746. return nblocks; /* no work */
  748. fd = _mdfd_getrelnfd(reln);
  749. v = &Md_fdvec[fd];
  751. #ifndef LET_OS_MANAGE_FILESIZE
  752. oldcxt = MemoryContextSwitchTo(MdCxt);
  753. priorblocks = 0;
  754. while (v != (MdfdVec *) NULL)
  755. {
  756. MdfdVec    *ov = v;
  758. if (priorblocks > nblocks)
  759. {
  760. /* This segment is no longer wanted at all (and has already been
  761.  * unlinked from the mdfd_chain).
  762.  * We truncate the file before deleting it because if other
  763.  * backends are holding the file open, the unlink will fail on
  764.  * some platforms.  Better a zero-size file gets left around than
  765.  * a big file...
  766.  */
  767. FileTruncate(v->mdfd_vfd, 0);
  768. /* In 6.5, it is not safe to unlink apparently-unused segments,
  769.  * because another backend could store tuples in one of those
  770.  * segments before it notices the shared-cache-invalidation
  771.  * message that would warn it to re-open the file.  So, don't
  772.  * unlink 'em, just truncate 'em.  This is fixed properly for 6.6
  773.  * but back-patching the changes was judged too risky.
  774.  */
  775. #if 0
  776. FileUnlink(v->mdfd_vfd);
  777. #endif
  778. v = v->mdfd_chain;
  779. Assert(ov != &Md_fdvec[fd]); /* we never drop the 1st segment */
  780. pfree(ov);
  781. }
  782. else if (priorblocks + RELSEG_SIZE > nblocks)
  783. {
  784. /* This is the last segment we want to keep.
  785.  * Truncate the file to the right length, and clear chain link
  786.  * that points to any remaining segments (which we shall zap).
  787.  * NOTE: if nblocks is exactly a multiple K of RELSEG_SIZE,
  788.  * we will truncate the K+1st segment to 0 length but keep it.
  789.  * This is mainly so that the right thing happens if nblocks=0.
  790.  */
  791. int lastsegblocks = nblocks - priorblocks;
  792. if (FileTruncate(v->mdfd_vfd, lastsegblocks * BLCKSZ) < 0)
  793. return -1;
  794. v->mdfd_lstbcnt = lastsegblocks;
  795. v = v->mdfd_chain;
  796. ov->mdfd_chain = (MdfdVec *) NULL;
  797. }
  798. else
  799. {
  800. /* We still need this segment and 0 or more blocks beyond it,
  801.  * so nothing to do here.
  802.  */
  803. v = v->mdfd_chain;
  804. }
  805. priorblocks += RELSEG_SIZE;
  806. }
  807. MemoryContextSwitchTo(oldcxt);
  808. #else
  809. if (FileTruncate(v->mdfd_vfd, nblocks * BLCKSZ) < 0)
  810. return -1;
  811. v->mdfd_lstbcnt = nblocks;
  812. #endif
  814. return nblocks;
  816. } /* mdtruncate */
  818. /*
  819.  * mdcommit() -- Commit a transaction.
  820.  *
  821.  * All changes to magnetic disk relations must be forced to stable
  822.  * storage.  This routine makes a pass over the private table of
  823.  * file descriptors.  Any descriptors to which we have done writes,
  824.  * but not synced, are synced here.
  825.  *
  826.  * Returns SM_SUCCESS or SM_FAIL with errno set as appropriate.
  827.  */
  828. int
  829. mdcommit()
  830. {
  831. int i;
  832. MdfdVec    *v;
  834. for (i = 0; i < CurFd; i++)
  835. {
  836. #ifndef LET_OS_MANAGE_FILESIZE
  837. for (v = &Md_fdvec[i]; v != (MdfdVec *) NULL; v = v->mdfd_chain)
  838. #else
  839. v = &Md_fdvec[i];
  840. if (v != (MdfdVec *) NULL)
  841. #endif
  842. {
  843. if (v->mdfd_flags & MDFD_DIRTY)
  844. {
  845. if (FileSync(v->mdfd_vfd) < 0)
  846. return SM_FAIL;
  848. v->mdfd_flags &= ~MDFD_DIRTY;
  849. }
  850. }
  851. }
  853. return SM_SUCCESS;
  854. }
  856. /*
  857.  * mdabort() -- Abort a transaction.
  858.  *
  859.  * Changes need not be forced to disk at transaction abort.  We mark
  860.  * all file descriptors as clean here.  Always returns SM_SUCCESS.
  861.  */
  862. int
  863. mdabort()
  864. {
  865. int i;
  866. MdfdVec    *v;
  868. for (i = 0; i < CurFd; i++)
  869. {
  870. #ifndef LET_OS_MANAGE_FILESIZE
  871. for (v = &Md_fdvec[i]; v != (MdfdVec *) NULL; v = v->mdfd_chain)
  872. v->mdfd_flags &= ~MDFD_DIRTY;
  873. #else
  874. v = &Md_fdvec[i];
  875. v->mdfd_flags &= ~MDFD_DIRTY;
  876. #endif
  877. }
  879. return SM_SUCCESS;
  880. }
  882. /*
  883.  * _fdvec_alloc () -- grab a free (or new) md file descriptor vector.
  884.  *
  885.  */
  886. static
  887. int
  888. _fdvec_alloc()
  889. {
  890. MdfdVec    *nvec;
  891. int fdvec,
  892. i;
  893. MemoryContext oldcxt;
  895. if (Md_Free >= 0) /* get from free list */
  896. {
  897. fdvec = Md_Free;
  898. Md_Free = Md_fdvec[fdvec].mdfd_nextFree;
  899. Assert(Md_fdvec[fdvec].mdfd_flags == MDFD_FREE);
  900. Md_fdvec[fdvec].mdfd_flags = 0;
  901. if (fdvec >= CurFd)
  902. {
  903. Assert(fdvec == CurFd);
  904. CurFd++;
  905. }
  906. return fdvec;
  907. }
  909. /* Must allocate more room */
  911. if (Nfds != CurFd)
  912. elog(FATAL, "_fdvec_alloc error");
  914. Nfds *= 2;
  916. oldcxt = MemoryContextSwitchTo(MdCxt);
  918. nvec = (MdfdVec *) palloc(Nfds * sizeof(MdfdVec));
  919. MemSet(nvec, 0, Nfds * sizeof(MdfdVec));
  920. memmove(nvec, (char *) Md_fdvec, CurFd * sizeof(MdfdVec));
  921. pfree(Md_fdvec);
  923. MemoryContextSwitchTo(oldcxt);
  925. Md_fdvec = nvec;
  927. /* Set new free list */
  928. for (i = CurFd; i < Nfds; i++)
  929. {
  930. Md_fdvec[i].mdfd_nextFree = i + 1;
  931. Md_fdvec[i].mdfd_flags = MDFD_FREE;
  932. }
  933. Md_fdvec[Nfds - 1].mdfd_nextFree = -1;
  934. Md_Free = CurFd + 1;
  936. fdvec = CurFd;
  937. CurFd++;
  938. Md_fdvec[fdvec].mdfd_flags = 0;
  940. return fdvec;
  941. }
  943. /*
  944.  * _fdvec_free () -- free md file descriptor vector.
  945.  *
  946.  */
  947. static
  948. void
  949. _fdvec_free(int fdvec)
  950. {
  952. Assert(Md_Free < 0 || Md_fdvec[Md_Free].mdfd_flags == MDFD_FREE);
  953. Assert(Md_fdvec[fdvec].mdfd_flags != MDFD_FREE);
  954. Md_fdvec[fdvec].mdfd_nextFree = Md_Free;
  955. Md_fdvec[fdvec].mdfd_flags = MDFD_FREE;
  956. Md_Free = fdvec;
  958. }
  960. static MdfdVec *
  961. _mdfd_openseg(Relation reln, int segno, int oflags)
  962. {
  963. MemoryContext oldcxt;
  964. MdfdVec    *v;
  965. int fd;
  966. bool dofree;
  967. char    *path,
  968.    *fullpath;
  970. /* be sure we have enough space for the '.segno', if any */
  971. path = relpath(RelationGetRelationName(reln)->data);
  973. dofree = false;
  974. if (segno > 0)
  975. {
  976. dofree = true;
  977. fullpath = (char *) palloc(strlen(path) + 12);
  978. sprintf(fullpath, "%s.%d", path, segno);
  979. }
  980. else
  981. fullpath = path;
  983. /* open the file */
  984. #ifndef __CYGWIN32__
  985. fd = FileNameOpenFile(fullpath, O_RDWR | oflags, 0600);
  986. #else
  987. fd = FileNameOpenFile(fullpath, O_RDWR | O_BINARY | oflags, 0600);
  988. #endif
  990. if (dofree)
  991. pfree(fullpath);
  993. if (fd < 0)
  994. return (MdfdVec *) NULL;
  996. /* allocate an mdfdvec entry for it */
  997. oldcxt = MemoryContextSwitchTo(MdCxt);
  998. v = (MdfdVec *) palloc(sizeof(MdfdVec));
  999. MemoryContextSwitchTo(oldcxt);
  1001. /* fill the entry */
  1002. v->mdfd_vfd = fd;
  1003. v->mdfd_flags = (uint16) 0;
  1004. v->mdfd_lstbcnt = _mdnblocks(fd, BLCKSZ);
  1005. #ifndef LET_OS_MANAGE_FILESIZE
  1006. v->mdfd_chain = (MdfdVec *) NULL;
  1008. #ifdef DIAGNOSTIC
  1009. if (v->mdfd_lstbcnt > RELSEG_SIZE)
  1010. elog(FATAL, "segment too big on open!");
  1011. #endif
  1012. #endif
  1014. /* all done */
  1015. return v;
  1016. }
  1018. /* Get the fd for the relation, opening it if it's not already open */
  1020. static int
  1021. _mdfd_getrelnfd(Relation reln)
  1022. {
  1023. int fd;
  1025. fd = RelationGetFile(reln);
  1026. if (fd < 0)
  1027. {
  1028. if ((fd = mdopen(reln)) < 0)
  1029. elog(ERROR, "cannot open relation %s",
  1030.  RelationGetRelationName(reln));
  1031. reln->rd_fd = fd;
  1032. }
  1033. return fd;
  1034. }
  1036. /* Find the segment of the relation holding the specified block */
  1038. static MdfdVec *
  1039. _mdfd_getseg(Relation reln, int blkno)
  1040. {
  1041. MdfdVec    *v;
  1042. int segno;
  1043. int fd;
  1044. int i;
  1046. fd = _mdfd_getrelnfd(reln);
  1048. #ifndef LET_OS_MANAGE_FILESIZE
  1049. for (v = &Md_fdvec[fd], segno = blkno / RELSEG_SIZE, i = 1;
  1050.  segno > 0;
  1051.  i++, segno--)
  1052. {
  1054. if (v->mdfd_chain == (MdfdVec *) NULL)
  1055. {
  1056. v->mdfd_chain = _mdfd_openseg(reln, i, O_CREAT);
  1058. if (v->mdfd_chain == (MdfdVec *) NULL)
  1059. elog(ERROR, "cannot open segment %d of relation %s",
  1060.  i, RelationGetRelationName(reln));
  1061. }
  1062. v = v->mdfd_chain;
  1063. }
  1064. #else
  1065. v = &Md_fdvec[fd];
  1066. #endif
  1068. return v;
  1069. }
  1071. static BlockNumber
  1072. _mdnblocks(File file, Size blcksz)
  1073. {
  1074. long len;
  1076. len = FileSeek(file, 0L, SEEK_END) - 1;
  1077. return (BlockNumber) ((len < 0) ? 0 : 1 + len / blcksz);
  1078. }