database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-12 05:01:15 +03:00
Code Activity

pgindent run before 6.3 release, with Thomas' requested changes.

Browse Source
This commit is contained in:
Bruce Momjian
1998-02-26 04:46:47 +00:00
parent 757bf69a2e
commit a32450a585
430 changed files with 12390 additions and 10292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/backend/storage/buffer/bufmgr.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.34 1998/02/11 19:11:42 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.35 1998/02/26 04:35:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -100,7 +100,7 @@ static void BufferSync(void);
static int BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld);
/* not static but used by vacuum only ... */
int BlowawayRelationBuffers(Relation rdesc, BlockNumber block);
int BlowawayRelationBuffers(Relation rdesc, BlockNumber block);
/* ---------------------------------------------------
* RelationGetBufferWithBuffer
@@ -829,7 +829,7 @@ FlushBuffer(Buffer buffer, bool release)
status = smgrflush(DEFAULT_SMGR, bufrel, bufHdr->tag.blockNum,
(char *) MAKE_PTR(bufHdr->data));
RelationDecrementReferenceCount(bufrel);
if (status == SM_FAIL)
@@ -1197,7 +1197,7 @@ ResetBufferUsage()
void
ResetBufferPool()
{
int i;
int i;
for (i = 1; i <= NBuffers; i++)
{
@@ -1225,7 +1225,7 @@ ResetBufferPool()
int
BufferPoolCheckLeak()
{
int i;
int i;
int error = 0;
for (i = 1; i <= NBuffers; i++)
@@ -1384,7 +1384,7 @@ BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld)
bufHdr->tag.blockNum,
(char *) MAKE_PTR(bufHdr->data));
}
if (reln != (Relation) NULL)
RelationDecrementReferenceCount(reln);
@@ -1444,7 +1444,7 @@ BufferGetBlock(Buffer buffer)
void
ReleaseRelationBuffers(Relation rdesc)
{
int i;
int i;
int holding = 0;
BufferDesc *buf;
@@ -1501,7 +1501,7 @@ ReleaseRelationBuffers(Relation rdesc)
void
DropBuffers(Oid dbid)
{
int i;
int i;
BufferDesc *buf;
SpinAcquire(BufMgrLock);
@@ -1587,7 +1587,7 @@ blockNum=%d, flags=0x%x, refcount=%d %d)\n",
void
BufferPoolBlowaway()
{
int i;
int i;
BufferSync();
for (i = 1; i <= NBuffers; i++)
@@ -1608,9 +1608,9 @@ BufferPoolBlowaway()
*
* This function blowaway all the pages with blocknumber >= passed
* of a relation in the buffer pool. Used by vacuum before truncation...
*
*
* Returns: 0 - Ok, -1 - DIRTY, -2 - PINNED
*
*
* XXX currently it sequentially searches the buffer pool, should be
* changed to more clever ways of searching.
* --------------------------------------------------------------------
@@ -1618,28 +1618,28 @@ BufferPoolBlowaway()
int
BlowawayRelationBuffers(Relation rdesc, BlockNumber block)
{
int i;
BufferDesc *buf;
int i;
BufferDesc *buf;
if (rdesc->rd_islocal)
{
for (i = 0; i < NLocBuffer; i++)
{
buf = &LocalBufferDescriptors[i];
if (buf->tag.relId.relId == rdesc->rd_id &&
if (buf->tag.relId.relId == rdesc->rd_id &&
buf->tag.blockNum >= block)
{
if (buf->flags & BM_DIRTY)
{
elog (NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is dirty",
rdesc->rd_rel->relname.data, block, buf->tag.blockNum);
elog(NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is dirty",
rdesc->rd_rel->relname.data, block, buf->tag.blockNum);
return (-1);
}
if (LocalRefCount[i] > 0)
{
elog (NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is referenced (%d)",
rdesc->rd_rel->relname.data, block,
buf->tag.blockNum, LocalRefCount[i]);
elog(NOTICE, "BlowawayRelationBuffers(%s (local), %u): block %u is referenced (%d)",
rdesc->rd_rel->relname.data, block,
buf->tag.blockNum, LocalRefCount[i]);
return (-2);
}
buf->tag.relId.relId = InvalidOid;
@@ -1653,22 +1653,22 @@ BlowawayRelationBuffers(Relation rdesc, BlockNumber block)
{
buf = &BufferDescriptors[i];
if (buf->tag.relId.dbId == MyDatabaseId &&
buf->tag.relId.relId == rdesc->rd_id &&
buf->tag.relId.relId == rdesc->rd_id &&
buf->tag.blockNum >= block)
{
if (buf->flags & BM_DIRTY)
{
elog (NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is dirty (private %d, last %d, global %d)",
buf->sb_relname, block, buf->tag.blockNum,
PrivateRefCount[i], LastRefCount[i], buf->refcount);
elog(NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is dirty (private %d, last %d, global %d)",
buf->sb_relname, block, buf->tag.blockNum,
PrivateRefCount[i], LastRefCount[i], buf->refcount);
SpinRelease(BufMgrLock);
return (-1);
}
if (!(buf->flags & BM_FREE))
{
elog (NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is referenced (private %d, last %d, global %d)",
buf->sb_relname, block, buf->tag.blockNum,
PrivateRefCount[i], LastRefCount[i], buf->refcount);
elog(NOTICE, "BlowawayRelationBuffers(%s, %u): block %u is referenced (private %d, last %d, global %d)",
buf->sb_relname, block, buf->tag.blockNum,
PrivateRefCount[i], LastRefCount[i], buf->refcount);
SpinRelease(BufMgrLock);
return (-2);
}

6
src/backend/storage/buffer/localbuf.c
View File

@@ -15,7 +15,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.17 1998/01/13 04:04:20 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.18 1998/02/26 04:35:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -205,7 +205,7 @@ FlushLocalBuffer(Buffer buffer, bool release)
(char *) MAKE_PTR(bufHdr->data));
LocalBufferFlushCount++;
RelationDecrementReferenceCount(bufrel);
Assert(LocalRefCount[bufid] > 0);
if (release)
LocalRefCount[bufid]--;
@@ -279,7 +279,7 @@ LocalBufferSync(void)
(char *) MAKE_PTR(buf->data));
LocalBufferFlushCount++;
RelationDecrementReferenceCount(bufrel);
buf->tag.relId.relId = InvalidOid;
buf->flags &= ~BM_DIRTY;
}

29
src/backend/storage/buffer/s_lock.c
View File

@@ -7,15 +7,15 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.2 1998/01/07 17:02:52 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/buffer/Attic/s_lock.c,v 1.3 1998/02/26 04:35:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* S_LOCK() -- Implements the S_LOCK function for the Linux/Alpha platform.
* This function is usually an inlined macro for all other platforms,
* but must be a seperate function for the Linux/Alpha platform, due
* to the assembly code involved.
* This function is usually an inlined macro for all other platforms,
* but must be a seperate function for the Linux/Alpha platform, due
* to the assembly code involved.
*/
@@ -38,14 +38,16 @@
#include "storage/s_lock.h"
#if defined(__alpha__) && defined(linux)
void S_LOCK(slock_t* lock)
void
S_LOCK(slock_t *lock)
{
do
{
slock_t _res;
do
{
__asm__(" ldq $0, %0 \n\
do
{
slock_t _res;
do
{
__asm__(" ldq $0, %0 \n\
bne $0, already_set \n\
ldq_l $0, %0 \n\
bne $0, already_set \n\
@@ -58,7 +60,8 @@ void S_LOCK(slock_t* lock)
stqc_fail: or $31, 1, $0 \n\
already_set: bis $0, $0, %1 \n\
end: nop ": "=m"(*lock), "=r"(_res): :"0");
} while (_res != 0);
} while (0);
} while (_res != 0);
} while (0);
}
#endif

6
src/backend/storage/file/fd.c
View File

@@ -6,7 +6,7 @@
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Id: fd.c,v 1.29 1998/01/07 21:04:58 momjian Exp $
* $Id: fd.c,v 1.30 1998/02/26 04:35:29 momjian Exp $
*
* NOTES:
*
@@ -483,7 +483,7 @@ filepath(char *filename)
}
#ifdef FILEDEBUG
printf("filepath: path is %s\n", buf);
printf("filepath: path is %s\n", buf);
#endif
return (buf);
@@ -852,7 +852,7 @@ FileNameUnlink(char *filename)
*/
static int allocatedFiles = 0;
FILE *
FILE *
AllocateFile(char *name, char *mode)
{
FILE *file;

7
src/backend/storage/ipc/ipc.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.18 1998/01/07 21:05:03 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.19 1998/02/26 04:35:38 momjian Exp $
*
* NOTES
*
@@ -561,7 +561,7 @@ IpcMemoryDetach(int status, char *shmaddr)
/* CALL IT: addr = (struct <MemoryStructure> *) IpcMemoryAttach(memId); */
/* */
/****************************************************************************/
char *
char *
IpcMemoryAttach(IpcMemoryId memId)
{
char *memAddress;
@@ -618,7 +618,7 @@ IpcMemoryKill(IpcMemoryKey memKey)
*/
/* used in spin.c */
SLock *SLockArray = NULL;
SLock *SLockArray = NULL;
static SLock **FreeSLockPP;
static int *UnusedSLockIP;
@@ -686,6 +686,7 @@ LockIsFree(int lockid)
{
return (SLockArray[lockid].flag == NOLOCK);
}
#endif
#endif /* HAS_TEST_AND_SET */

8
src/backend/storage/ipc/shmem.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.16 1998/01/07 21:05:08 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.17 1998/02/26 04:35:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -276,7 +276,7 @@ InitShmem(unsigned int key, unsigned int size)
* of space. Has to return a real pointer in order
* to be compatable with malloc().
*/
long *
long *
ShmemAlloc(unsigned long size)
{
unsigned long tmpFree;
@@ -338,7 +338,7 @@ ShmemIsValid(unsigned long addr)
* table at once. Use SpinAlloc() to create a spinlock
* for the structure before creating the structure itself.
*/
HTAB *
HTAB *
ShmemInitHash(char *name, /* table string name for binding */
long init_size, /* initial size */
long max_size, /* max size of the table */
@@ -496,7 +496,7 @@ ShmemPIDDestroy(int pid)
* the object is already in the binding table (hence, already
* initialized).
*/
long *
long *
ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
{
BindingEnt *result,

103
src/backend/storage/lmgr/lock.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.25 1998/01/28 06:52:58 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.26 1998/02/26 04:36:07 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
@@ -50,9 +50,10 @@
#include "access/xact.h"
#include "access/transam.h"
static int WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
static int
WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
LOCKT lockt);
/*#define LOCK_MGR_DEBUG*/
#ifndef LOCK_MGR_DEBUG
@@ -542,7 +543,7 @@ LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt)
* word alignment and ensures hashing consistency).
* ------------------
*/
MemSet(&item, 0, XID_TAGSIZE); /* must clear padding, needed */
MemSet(&item, 0, XID_TAGSIZE); /* must clear padding, needed */
TransactionIdStore(myXid, &item.tag.xid);
item.tag.lock = MAKE_OFFSET(lock);
#if 0
@@ -713,12 +714,12 @@ LockResolveConflicts(LOCKTAB *ltable,
{
/* ------------------------
* If someone with a greater priority is waiting for the lock,
* do not continue and share the lock, even if we can. bjm
* do not continue and share the lock, even if we can. bjm
* ------------------------
*/
int myprio = ltable->ctl->prio[lockt];
PROC_QUEUE *waitQueue = &(lock->waitProcs);
PROC *topproc = (PROC *) MAKE_PTR(waitQueue->links.prev);
int myprio = ltable->ctl->prio[lockt];
PROC_QUEUE *waitQueue = &(lock->waitProcs);
PROC *topproc = (PROC *) MAKE_PTR(waitQueue->links.prev);
if (waitQueue->size && topproc->prio > myprio)
return STATUS_FOUND;
@@ -902,7 +903,8 @@ LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt)
#endif
/*
* let the caller print its own error message, too. Do not elog(ERROR).
* let the caller print its own error message, too. Do not
* elog(ERROR).
*/
if (!lock)
{
@@ -1430,16 +1432,16 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
SHMEM_OFFSET end = MAKE_OFFSET(lockQueue);
LOCK *lock;
LOCKTAB *ltable;
LOCKTAB *ltable;
XIDLookupEnt *result,
item;
HTAB *xidTable;
bool found;
static PROC* checked_procs[MaxBackendId];
static int nprocs;
static bool MyNHolding;
static PROC *checked_procs[MaxBackendId];
static int nprocs;
static bool MyNHolding;
/* initialize at start of recursion */
if (skip_check)
{
@@ -1455,15 +1457,15 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
#if 0
item.tag.pid = pid;
#endif
if (!(result = (XIDLookupEnt *)
hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
{
elog(NOTICE, "LockAcquire: xid table corrupted");
return true;
}
MyNHolding = result->nHolding;
}
}
if (SHMQueueEmpty(lockQueue))
return false;
@@ -1487,19 +1489,19 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
/*
* This is our only check to see if we found the lock we want.
*
* The lock we are waiting for is already in MyProc->lockQueue
* so we need to skip it here. We are trying to find it in
* someone else's lockQueue.
* The lock we are waiting for is already in MyProc->lockQueue so we
* need to skip it here. We are trying to find it in someone
* else's lockQueue.
*/
if (lock == findlock && !skip_check)
return true;
{
PROC_QUEUE *waitQueue = &(lock->waitProcs);
PROC *proc;
{
PROC_QUEUE *waitQueue = &(lock->waitProcs);
PROC *proc;
int i;
int j;
proc = (PROC *) MAKE_PTR(waitQueue->links.prev);
for (i = 0; i < waitQueue->size; i++)
{
@@ -1507,23 +1509,24 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
lock == findlock && /* skip_check also true */
MyNHolding) /* I already hold some lock on it */
{
/*
* For findlock's wait queue, we are interested in
* procs who are blocked waiting for a write-lock on the
* table we are waiting on, and already hold a lock on it.
* We first check to see if there is an escalation
* deadlock, where we hold a readlock and want a
* writelock, and someone else holds readlock on
* the same table, and wants a writelock.
* For findlock's wait queue, we are interested in
* procs who are blocked waiting for a write-lock on
* the table we are waiting on, and already hold a
* lock on it. We first check to see if there is an
* escalation deadlock, where we hold a readlock and
* want a writelock, and someone else holds readlock
* on the same table, and wants a writelock.
*
* Basically, the test is, "Do we both hold some lock
* on findlock, and we are both waiting in the lock
* queue?"
* Basically, the test is, "Do we both hold some lock on
* findlock, and we are both waiting in the lock
* queue?"
*/
Assert(skip_check);
Assert(MyProc->prio == 2);
ltable = AllTables[1];
xidTable = ltable->xidHash;
@@ -1533,9 +1536,9 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
#if 0
item.tag.pid = pid;
#endif
if (!(result = (XIDLookupEnt *)
hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
hash_search(xidTable, (Pointer) &item, HASH_FIND, &found)) || !found)
{
elog(NOTICE, "LockAcquire: xid table corrupted");
return true;
@@ -1543,11 +1546,11 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
if (result->nHolding)
return true;
}
/*
* No sense in looking at the wait queue of the lock we are
* looking for.
* If lock == findlock, and I got here, skip_check must be
* true too.
* No sense in looking at the wait queue of the lock we
* are looking for. If lock == findlock, and I got here,
* skip_check must be true too.
*/
if (lock != findlock)
{
@@ -1558,13 +1561,14 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
{
checked_procs[nprocs++] = proc;
Assert(nprocs <= MaxBackendId);
/*
* For non-MyProc entries, we are looking only waiters,
* not necessarily people who already hold locks and are
* waiting.
* Now we check for cases where we have two or more
* tables in a deadlock. We do this by continuing
* to search for someone holding a lock
* For non-MyProc entries, we are looking only
* waiters, not necessarily people who already
* hold locks and are waiting. Now we check for
* cases where we have two or more tables in a
* deadlock. We do this by continuing to search
* for someone holding a lock
*/
if (DeadLockCheck(&(proc->lockQueue), findlock, false))
return true;
@@ -1573,7 +1577,7 @@ DeadLockCheck(SHM_QUEUE *lockQueue, LOCK *findlock, bool skip_check)
proc = (PROC *) MAKE_PTR(proc->links.prev);
}
}
if (done)
break;
SHMQueueFirst(&xidLook->queue, (Pointer *) &tmp, &tmp->queue);
@@ -1601,7 +1605,8 @@ DumpLocks()
SPINLOCK masterLock;
int nLockTypes;
LOCK *lock;
count;
count;
int tableId = 1;
LOCKTAB *ltable;

46
src/backend/storage/lmgr/proc.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.33 1998/02/25 00:31:14 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.34 1998/02/26 04:36:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -46,7 +46,7 @@
* This is so that we can support more backends. (system-wide semaphore
* sets run out pretty fast.) -ay 4/95
*
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.33 1998/02/25 00:31:14 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.34 1998/02/26 04:36:12 momjian Exp $
*/
#include <sys/time.h>
#include <unistd.h>
@@ -457,25 +457,22 @@ ProcSleep(PROC_QUEUE *waitQueue,
dummy;
/*
* If the first entries in the waitQueue have a greater priority than
* we have, we must be a reader, and they must be a writers, and we
* must be here because the current holder is a writer or a
* reader but we don't share shared locks if a writer is waiting.
* We put ourselves after the writers. This way, we have a FIFO, but
* keep the readers together to give them decent priority, and no one
* starves. Because we group all readers together, a non-empty queue
* only has a few possible configurations:
* If the first entries in the waitQueue have a greater priority than
* we have, we must be a reader, and they must be a writers, and we
* must be here because the current holder is a writer or a reader but
* we don't share shared locks if a writer is waiting. We put
* ourselves after the writers. This way, we have a FIFO, but keep
* the readers together to give them decent priority, and no one
* starves. Because we group all readers together, a non-empty queue
* only has a few possible configurations:
*
* [readers]
* [writers]
* [readers][writers]
* [writers][readers]
* [writers][readers][writers]
* [readers] [writers] [readers][writers] [writers][readers]
* [writers][readers][writers]
*
* In a full queue, we would have a reader holding a lock, then a
* writer gets the lock, then a bunch of readers, made up of readers
* who could not share the first readlock because a writer was waiting,
* and new readers arriving while the writer had the lock.
* In a full queue, we would have a reader holding a lock, then a writer
* gets the lock, then a bunch of readers, made up of readers who
* could not share the first readlock because a writer was waiting,
* and new readers arriving while the writer had the lock.
*
*/
proc = (PROC *) MAKE_PTR(waitQueue->links.prev);
@@ -486,13 +483,13 @@ ProcSleep(PROC_QUEUE *waitQueue,
proc = (PROC *) MAKE_PTR(proc->links.prev);
/* The rest of the queue is FIFO, with readers first, writers last */
for ( ; i < waitQueue->size && proc->prio <= prio; i++)
for (; i < waitQueue->size && proc->prio <= prio; i++)
proc = (PROC *) MAKE_PTR(proc->links.prev);
MyProc->prio = prio;
MyProc->token = token;
MyProc->waitLock = lock;
/* -------------------
* currently, we only need this for the ProcWakeup routines
* -------------------
@@ -523,7 +520,7 @@ ProcSleep(PROC_QUEUE *waitQueue,
do
{
MyProc->errType = NO_ERROR; /* reset flag after deadlock check */
MyProc->errType = NO_ERROR; /* reset flag after deadlock check */
if (setitimer(ITIMER_REAL, &timeval, &dummy))
elog(FATAL, "ProcSleep: Unable to set timer for process wakeup");
@@ -535,8 +532,9 @@ ProcSleep(PROC_QUEUE *waitQueue,
* --------------
*/
IpcSemaphoreLock(MyProc->sem.semId, MyProc->sem.semNum, IpcExclusiveLock);
} while (MyProc->errType == STATUS_NOT_FOUND); /* sleep after deadlock check */
} while (MyProc->errType == STATUS_NOT_FOUND); /* sleep after deadlock
* check */
/* ---------------
* We were awoken before a timeout - now disable the timer
* ---------------

30
src/backend/storage/smgr/md.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.28 1998/02/23 13:58:04 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.29 1998/02/26 04:36:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -67,7 +67,7 @@ static MemoryContext MdCxt;
* The number needs to be (2 ** 31) / BLCKSZ, but to be keep
* the math under MAXINT, pre-divide by 256 and use ...
*
* (((2 ** 23) / BLCKSZ) * (2 ** 8))
* (((2 ** 23) / BLCKSZ) * (2 ** 8))
*
* 07 Jan 98 darrenk
*/
@@ -505,33 +505,35 @@ mdblindwrt(char *dbstr,
/* user table? then put in user database area... */
else if (dbid == MyDatabaseId)
{
extern char *DatabasePath;
extern char *DatabasePath;
path = (char *) palloc(strlen(DatabasePath) + 2 * sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s%c%s", DatabasePath, SEP_CHAR, relstr);
else
sprintf(path, "%s%c%s.%d", DatabasePath, SEP_CHAR, relstr, segno);
}
else /* this is work arround only !!! */
else
/* this is work arround only !!! */
{
char dbpath[MAXPGPATH+1];
Oid owner, id;
char *tmpPath;
char dbpath[MAXPGPATH + 1];
Oid owner,
id;
char *tmpPath;
GetRawDatabaseInfo(dbstr, &owner, &id, dbpath);
if (id != dbid)
elog (FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
elog(FATAL, "mdblindwrt: oid of db %s is not %u", dbstr, dbid);
tmpPath = ExpandDatabasePath(dbpath);
if (tmpPath == NULL)
elog (FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
elog(FATAL, "mdblindwrt: can't expand path for db %s", dbstr);
path = (char *) palloc(strlen(tmpPath) + 2 * sizeof(NameData) + 2 + nchars);
if (segno == 0)
sprintf(path, "%s%c%s", tmpPath, SEP_CHAR, relstr);
else
sprintf(path, "%s%c%s.%d", tmpPath, SEP_CHAR, relstr, segno);
pfree (tmpPath);
pfree(tmpPath);
}
if ((fd = open(path, O_RDWR, 0600)) < 0)
@@ -635,7 +637,7 @@ mdtruncate(Relation reln, int nblocks)
return (nblocks);
} /* mdtruncate */
} /* mdtruncate */
/*
* mdcommit() -- Commit a transaction.

4
src/backend/storage/smgr/smgrtype.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.7 1998/01/07 21:05:47 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.8 1998/02/26 04:36:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -53,7 +53,7 @@ smgrin(char *s)
return 0;
}
char *
char *
smgrout(int2 i)
{
char *s;