Add zebrasrv.pid
[idzebra-moved-to-github.git] / bfile / commit.c
1 /* $Id: commit.c,v 1.16 2002-08-02 19:26:55 adam Exp $
2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
3    Index Data Aps
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23
24
25 #include <assert.h>
26 #include <stdlib.h>
27
28 #include <zebrautl.h>
29 #include <mfile.h>
30 #include "cfile.h"
31
32 #define CF_OPTIMIZE_COMMIT 0
33
34 void cf_unlink (CFile cf)
35 {
36     if (cf->bucket_in_memory)
37     {
38         logf (LOG_FATAL, "Cannot unlink potential dirty cache");
39         exit (1);
40     }
41     cf->head.state = 0;
42     cf->dirty = 1;
43     mf_unlink (cf->block_mf);
44     mf_unlink (cf->hash_mf);
45 }
46
47
48 #if CF_OPTIMIZE_COMMIT
49 struct map_cache_entity {
50     int from;
51     int to;
52 };
53
54 struct map_cache {
55     int max;
56     int no;
57
58     struct map_cache_entity *map;
59     char *buf;
60     CFile cf;
61 };
62
63 static struct map_cache *map_cache_init (CFile cf)
64 {
65     int mem_max = 2000000;
66     struct map_cache *m_p;
67
68     m_p = xmalloc (sizeof(*m_p));
69     m_p->cf = cf;
70     m_p->max = mem_max / cf->head.block_size;
71     m_p->buf = xmalloc (mem_max);
72     m_p->no = 0;
73     m_p->map = xmalloc (sizeof(*m_p->map) * m_p->max);
74     return m_p;
75 }
76
77 static int map_cache_cmp_from (const void *p1, const void *p2)
78 {
79     return ((struct map_cache_entity*) p1)->from -
80         ((struct map_cache_entity*) p2)->from;
81 }
82
83 static int map_cache_cmp_to (const void *p1, const void *p2)
84 {
85     return ((struct map_cache_entity*) p1)->to -
86         ((struct map_cache_entity*) p2)->to;
87 }
88
89 static void map_cache_flush (struct map_cache *m_p)
90 {
91     int i;
92
93     qsort (m_p->map, m_p->no, sizeof(*m_p->map), map_cache_cmp_from);
94     assert (m_p->no < 2 || m_p->map[0].from < m_p->map[1].from);
95     for (i = 0; i<m_p->no; i++)
96     {
97         if (!mf_read (m_p->cf->block_mf, m_p->map[i].from, 0, 0,
98                       m_p->buf + i * m_p->cf->head.block_size))
99         {
100             logf (LOG_FATAL, "read commit block at position %d",
101                   m_p->map[i].from);
102             exit (1);
103         }
104         m_p->map[i].from = i;
105     }
106     qsort (m_p->map, m_p->no, sizeof(*m_p->map), map_cache_cmp_to);
107     assert (m_p->no < 2 || m_p->map[0].to < m_p->map[1].to);
108     for (i = 0; i<m_p->no; i++)
109     {
110         mf_write (m_p->cf->rmf, m_p->map[i].to, 0, 0,
111                   m_p->buf + m_p->map[i].from * m_p->cf->head.block_size);
112     }    
113     m_p->no = 0;
114 }
115
116 static void map_cache_del (struct map_cache *m_p)
117 {
118     map_cache_flush (m_p);
119     xfree (m_p->map);
120     xfree (m_p->buf);
121     xfree (m_p);
122 }
123
124 static void map_cache_add (struct map_cache *m_p, int from, int to)
125 {
126     int i = m_p->no;
127
128     m_p->map[i].from = from;
129     m_p->map[i].to = to;
130     m_p->no = ++i;
131     if (i == m_p->max)
132         map_cache_flush (m_p);
133 }
134
135 /* CF_OPTIMIZE_COMMIT */
136 #endif
137
138 static void cf_commit_hash (CFile cf)
139
140     int i, bucket_no;
141     int hash_bytes;
142     struct CFile_ph_bucket *p;
143 #if CF_OPTIMIZE_COMMIT
144     struct map_cache *m_p;
145 #endif
146
147 #if CF_OPTIMIZE_COMMIT
148     m_p = map_cache_init (cf);
149 #endif
150
151     p = (struct CFile_ph_bucket *) xmalloc (sizeof(*p));
152     hash_bytes = cf->head.hash_size * sizeof(int);
153     bucket_no = cf->head.first_bucket;
154     for (; bucket_no < cf->head.next_bucket; bucket_no++)
155     {
156         if (!mf_read (cf->hash_mf, bucket_no, 0, 0, p))
157         {
158             logf (LOG_FATAL, "read commit hash");
159             exit (1);
160         }
161         for (i = 0; i<HASH_BUCKET && p->vno[i]; i++)
162         {
163 #if CF_OPTIMIZE_COMMIT
164             map_cache_add (m_p, p->vno[i], p->no[i]);
165 #else
166             if (!mf_read (cf->block_mf, p->vno[i], 0, 0, cf->iobuf))
167             {
168                 logf (LOG_FATAL, "read commit block");
169                 exit (1);
170             }
171             mf_write (cf->rmf, p->no[i], 0, 0, cf->iobuf);
172 #endif
173         }
174     }
175 #if CF_OPTIMIZE_COMMIT
176     map_cache_del (m_p);
177 #endif
178     xfree (p);
179 }
180
181 static void cf_commit_flat (CFile cf)
182 {
183     int *fp;
184     int hno;
185     int i, vno = 0;
186
187 #if CF_OPTIMIZE_COMMIT
188     struct map_cache *m_p;
189 #endif
190
191
192 #if CF_OPTIMIZE_COMMIT
193     m_p = map_cache_init (cf);
194 #endif
195     fp = (int *) xmalloc (HASH_BSIZE);
196     for (hno = cf->head.next_bucket; hno < cf->head.flat_bucket; hno++)
197     {
198         for (i = 0; i < (int) (HASH_BSIZE/sizeof(int)); i++)
199             fp[i] = 0;
200         if (!mf_read (cf->hash_mf, hno, 0, 0, fp) &&
201             hno != cf->head.flat_bucket-1)
202         {
203             logf (LOG_FATAL, "read index block hno=%d (%d-%d) commit",
204                   hno, cf->head.next_bucket, cf->head.flat_bucket-1);
205         }
206         for (i = 0; i < (int) (HASH_BSIZE/sizeof(int)); i++)
207         {
208             if (fp[i])
209             {
210 #if CF_OPTIMIZE_COMMIT
211                 map_cache_add (m_p, fp[i], vno);
212 #else
213                 if (!mf_read (cf->block_mf, fp[i], 0, 0, cf->iobuf))
214                 {
215                     logf (LOG_FATAL, "read data block hno=%d (%d-%d) "
216                                      "i=%d commit block at %d (->%d)",
217                           hno, cf->head.next_bucket, cf->head.flat_bucket-1,
218                           i, fp[i], vno);
219                     exit (1);
220                 }
221                 mf_write (cf->rmf, vno, 0, 0, cf->iobuf);
222
223 #endif
224             }
225             vno++;
226         }
227     }
228 #if CF_OPTIMIZE_COMMIT
229     map_cache_del (m_p);
230 #endif
231     xfree (fp);
232 }
233
234 void cf_commit (CFile cf)
235 {
236
237     if (cf->bucket_in_memory)
238     {
239         logf (LOG_FATAL, "Cannot commit potential dirty cache");
240         exit (1);
241     }
242     if (cf->head.state == 1)
243         cf_commit_hash (cf);
244     else if (cf->head.state == 2)
245         cf_commit_flat (cf);
246 }
247