← Back to branch summary

~ubuntu-branches/ubuntu/trusty/postgresql-8.4/trusty

« back to all changes in this revision

Viewing changes to src/backend/storage/smgr/smgr.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-11 16:59:35 UTC
  • mfrom: (5.1.1 karmic)
  • Revision ID: james.westby@ubuntu.com-20090711165935-jfwin6gfrxf0gfsi
Tags: 8.4.0-2
http://bugs.debian.org/536139
* debian/libpq-dev.install: Ship catalog/genbki.h. (Closes: #536139)
* debian/rules: Drop --enable-cassert for final release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/backend/storage/smgr/smgr.c
11
11
 *
12
12
 *
13
13
 * IDENTIFICATION
14
 
 *        $PostgreSQL: pgsql/src/backend/storage/smgr/smgr.c,v 1.116 2009/01/12 05:10:44 tgl Exp $
 
14
 *        $PostgreSQL: pgsql/src/backend/storage/smgr/smgr.c,v 1.117 2009/06/11 14:49:02 momjian Exp $
15
15
 *
16
16
 *-------------------------------------------------------------------------
17
17
 */
42
42
        void            (*smgr_shutdown) (void);                /* may be NULL */
43
43
        void            (*smgr_close) (SMgrRelation reln, ForkNumber forknum);
44
44
        void            (*smgr_create) (SMgrRelation reln, ForkNumber forknum,
45
 
                                                                bool isRedo);
 
45
                                                                                        bool isRedo);
46
46
        bool            (*smgr_exists) (SMgrRelation reln, ForkNumber forknum);
47
47
        void            (*smgr_unlink) (RelFileNode rnode, ForkNumber forknum,
48
 
                                                                bool isRedo);
 
48
                                                                                        bool isRedo);
49
49
        void            (*smgr_extend) (SMgrRelation reln, ForkNumber forknum,
50
50
                                                        BlockNumber blocknum, char *buffer, bool isTemp);
51
51
        void            (*smgr_prefetch) (SMgrRelation reln, ForkNumber forknum,
52
 
                                                                  BlockNumber blocknum);
 
52
                                                                                          BlockNumber blocknum);
53
53
        void            (*smgr_read) (SMgrRelation reln, ForkNumber forknum,
54
 
                                                          BlockNumber blocknum, char *buffer);
55
 
        void            (*smgr_write) (SMgrRelation reln, ForkNumber forknum, 
56
 
                                                   BlockNumber blocknum, char *buffer, bool isTemp);
 
54
                                                                                  BlockNumber blocknum, char *buffer);
 
55
        void            (*smgr_write) (SMgrRelation reln, ForkNumber forknum,
 
56
                                                        BlockNumber blocknum, char *buffer, bool isTemp);
57
57
        BlockNumber (*smgr_nblocks) (SMgrRelation reln, ForkNumber forknum);
58
58
        void            (*smgr_truncate) (SMgrRelation reln, ForkNumber forknum,
59
 
                                                                  BlockNumber nblocks, bool isTemp);
 
59
                                                                                   BlockNumber nblocks, bool isTemp);
60
60
        void            (*smgr_immedsync) (SMgrRelation reln, ForkNumber forknum);
61
61
        void            (*smgr_pre_ckpt) (void);                /* may be NULL */
62
62
        void            (*smgr_sync) (void);    /* may be NULL */
82
82
 
83
83
/* local function prototypes */
84
84
static void smgrshutdown(int code, Datum arg);
85
 
static void smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum, 
86
 
                                                                 int which, bool isTemp, bool isRedo);
 
85
static void smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum,
 
86
                                         int which, bool isTemp, bool isRedo);
87
87
 
88
88
 
89
89
/*
156
156
        /* Initialize it if not present before */
157
157
        if (!found)
158
158
        {
159
 
                int forknum;
 
159
                int                     forknum;
160
160
 
161
161
                /* hash_search already filled in the lookup key */
162
162
                reln->smgr_owner = NULL;
163
163
                reln->smgr_which = 0;   /* we only have md.c at present */
164
164
 
165
165
                /* mark it not open */
166
 
                for(forknum = 0; forknum <= MAX_FORKNUM; forknum++)
 
166
                for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
167
167
                        reln->md_fd[forknum] = NULL;
168
168
        }
169
169
 
209
209
smgrclose(SMgrRelation reln)
210
210
{
211
211
        SMgrRelation *owner;
212
 
        ForkNumber forknum;
 
212
        ForkNumber      forknum;
213
213
 
214
214
        for (forknum = 0; forknum <= MAX_FORKNUM; forknum++)
215
215
                (*(smgrsw[reln->smgr_which].smgr_close)) (reln, forknum);
286
286
smgrcreate(SMgrRelation reln, ForkNumber forknum, bool isRedo)
287
287
{
288
288
        /*
289
 
         * Exit quickly in WAL replay mode if we've already opened the file. 
290
 
         * If it's open, it surely must exist.
291
 
         */ 
 
289
         * Exit quickly in WAL replay mode if we've already opened the file. If
 
290
         * it's open, it surely must exist.
 
291
         */
292
292
        if (isRedo && reln->md_fd[forknum] != NULL)
293
293
                return;
294
294
 
334
334
 * Shared subroutine that actually does the unlink ...
335
335
 */
336
336
static void
337
 
smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum, 
 
337
smgr_internal_unlink(RelFileNode rnode, ForkNumber forknum,
338
338
                                         int which, bool isTemp, bool isRedo)
339
339
{
340
340
        /*
370
370
 *              causes intervening file space to become filled with zeroes.
371
371
 */
372
372
void
373
 
smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, 
 
373
smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
374
374
                   char *buffer, bool isTemp)
375
375
{
376
376
        (*(smgrsw[reln->smgr_which].smgr_extend)) (reln, forknum, blocknum,
395
395
 *              return pages in the format that POSTGRES expects.
396
396
 */
397
397
void
398
 
smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, 
 
398
smgrread(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
399
399
                 char *buffer)
400
400
{
401
401
        (*(smgrsw[reln->smgr_which].smgr_read)) (reln, forknum, blocknum, buffer);
417
417
 *              made to fsync the write before checkpointing.
418
418
 */
419
419
void
420
 
smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum, 
 
420
smgrwrite(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
421
421
                  char *buffer, bool isTemp)
422
422
{
423
423
        (*(smgrsw[reln->smgr_which].smgr_write)) (reln, forknum, blocknum,
527
527
                        (*(smgrsw[i].smgr_post_ckpt)) ();
528
528
        }
529
529
}
530