← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_locking.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-07-30 02:39:13 UTC
  • mto: (1115.3.11 captain)
  • mto: This revision was merged to the branch mainline in revision 1121.
  • Revision ID: osullivan.padraig@gmail.com-20090730023913-o2zuocp32l6btnc2
Removing references to MY_BITMAP throughout the code base and updating calls
to MyBitmap in various places to use the new interface.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_locking.cc
1
 
/* Copyright (C) 2000-2006 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
/*
17
 
  locking of isam-tables.
18
 
  reads info from a isam-table. Must be first request before doing any furter
19
 
  calls to any isamfunktion.  Is used to allow many process use the same
20
 
  isamdatabase.
21
 
*/
22
 
 
23
 
#include "myisam_priv.h"
24
 
#include "drizzled/charset_info.h"
25
 
#include <drizzled/util/test.h>
26
 
 
27
 
using namespace std;
28
 
using namespace drizzled;
29
 
 
30
 
        /* lock table by F_UNLCK, F_RDLCK or F_WRLCK */
31
 
 
32
 
int mi_lock_database(MI_INFO *info, int lock_type)
33
 
{
34
 
  int error;
35
 
  uint32_t count;
36
 
  MYISAM_SHARE *share=info->s;
37
 
  uint32_t flag;
38
 
 
39
 
  pthread_mutex_lock(&share->intern_lock);
40
 
  if (!info->s->in_use)
41
 
    info->s->in_use= new list<Session *>;
42
 
 
43
 
  if (lock_type == F_EXTRA_LCK)                 /* Used by TMP tables */
44
 
  {
45
 
    pthread_mutex_unlock(&share->intern_lock);
46
 
    ++share->w_locks;
47
 
    ++share->tot_locks;
48
 
    info->lock_type= lock_type;
49
 
    info->s->in_use->push_front(info->in_use);
50
 
    return(0);
51
 
  }
52
 
 
53
 
  flag=error=0;
54
 
  if (share->kfile >= 0)                /* May only be false on windows */
55
 
  {
56
 
    switch (lock_type) {
57
 
    case F_UNLCK:
58
 
      if (info->lock_type == F_RDLCK)
59
 
        count= --share->r_locks;
60
 
      else
61
 
        count= --share->w_locks;
62
 
      --share->tot_locks;
63
 
      if (info->lock_type == F_WRLCK && !share->w_locks &&
64
 
          !share->delay_key_write && flush_key_blocks(share->key_cache,
65
 
                                                      share->kfile,FLUSH_KEEP))
66
 
      {
67
 
        error=errno;
68
 
        mi_print_error(info->s, HA_ERR_CRASHED);
69
 
        mi_mark_crashed(info);          /* Mark that table must be checked */
70
 
      }
71
 
      if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
72
 
      {
73
 
        if (end_io_cache(&info->rec_cache))
74
 
        {
75
 
          error=errno;
76
 
          mi_print_error(info->s, HA_ERR_CRASHED);
77
 
          mi_mark_crashed(info);
78
 
        }
79
 
      }
80
 
      if (!count)
81
 
      {
82
 
        if (share->changed && !share->w_locks)
83
 
        {
84
 
    if ((info->s->mmaped_length != info->s->state.state.data_file_length) &&
85
 
        (info->s->nonmmaped_inserts > MAX_NONMAPPED_INSERTS))
86
 
    {
87
 
      if (info->s->concurrent_insert)
88
 
        pthread_rwlock_wrlock(&info->s->mmap_lock);
89
 
      mi_remap_file(info, info->s->state.state.data_file_length);
90
 
      info->s->nonmmaped_inserts= 0;
91
 
      if (info->s->concurrent_insert)
92
 
        pthread_rwlock_unlock(&info->s->mmap_lock);
93
 
    }
94
 
          share->state.process= share->last_process=share->this_process;
95
 
          share->state.unique=   info->last_unique=  info->this_unique;
96
 
          share->state.update_count= info->last_loop= ++info->this_loop;
97
 
          if (mi_state_info_write(share->kfile, &share->state, 1))
98
 
            error=errno;
99
 
          share->changed=0;
100
 
          share->not_flushed=1;
101
 
          if (error)
102
 
          {
103
 
            mi_print_error(info->s, HA_ERR_CRASHED);
104
 
            mi_mark_crashed(info);
105
 
          }
106
 
        }
107
 
        if (info->lock_type != F_EXTRA_LCK)
108
 
        {
109
 
          if (share->r_locks)
110
 
          {                                     /* Only read locks left */
111
 
            flag=1;
112
 
          }
113
 
          else if (!share->w_locks)
114
 
          {                                     /* No more locks */
115
 
            flag=1;
116
 
          }
117
 
        }
118
 
      }
119
 
      info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
120
 
      info->lock_type= F_UNLCK;
121
 
      info->s->in_use->remove(info->in_use);
122
 
      break;
123
 
    case F_RDLCK:
124
 
      if (info->lock_type == F_WRLCK)
125
 
      {
126
 
        /*
127
 
          Change RW to READONLY
128
 
 
129
 
          mysqld does not turn write locks to read locks,
130
 
          so we're never here in mysqld.
131
 
        */
132
 
        if (share->w_locks == 1)
133
 
        {
134
 
          flag=1;
135
 
        }
136
 
        share->w_locks--;
137
 
        share->r_locks++;
138
 
        info->lock_type=lock_type;
139
 
        break;
140
 
      }
141
 
      if (!share->r_locks && !share->w_locks)
142
 
      {
143
 
        flag=1;
144
 
        if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
145
 
        {
146
 
          error=errno;
147
 
          break;
148
 
        }
149
 
        if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
150
 
        {
151
 
          error=errno;
152
 
          errno=error;
153
 
          break;
154
 
        }
155
 
      }
156
 
      _mi_test_if_changed(info);
157
 
      share->r_locks++;
158
 
      share->tot_locks++;
159
 
      info->lock_type=lock_type;
160
 
      info->s->in_use->push_front(info->in_use);
161
 
      break;
162
 
    case F_WRLCK:
163
 
      if (info->lock_type == F_RDLCK)
164
 
      {                                         /* Change READONLY to RW */
165
 
        if (share->r_locks == 1)
166
 
        {
167
 
          flag=1;
168
 
          share->r_locks--;
169
 
          share->w_locks++;
170
 
          info->lock_type=lock_type;
171
 
          break;
172
 
        }
173
 
      }
174
 
      if (!(share->options & HA_OPTION_READ_ONLY_DATA))
175
 
      {
176
 
        if (!share->w_locks)
177
 
        {
178
 
          flag=1;
179
 
          if (!share->r_locks)
180
 
          {
181
 
            if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
182
 
            {
183
 
              error=errno;
184
 
              errno=error;
185
 
              break;
186
 
            }
187
 
          }
188
 
        }
189
 
      }
190
 
      _mi_test_if_changed(info);
191
 
 
192
 
      info->lock_type=lock_type;
193
 
      share->w_locks++;
194
 
      share->tot_locks++;
195
 
      info->s->in_use->push_front(info->in_use);
196
 
      break;
197
 
    default:
198
 
      break;                            /* Impossible */
199
 
    }
200
 
  }
201
 
#ifdef __WIN__
202
 
  else
203
 
  {
204
 
    /*
205
 
       Check for bad file descriptors if this table is part
206
 
       of a merge union. Failing to capture this may cause
207
 
       a crash on windows if the table is renamed and
208
 
       later on referenced by the merge table.
209
 
     */
210
 
    if( info->owned_by_merge && (info->s)->kfile < 0 )
211
 
    {
212
 
      error = HA_ERR_NO_SUCH_TABLE;
213
 
    }
214
 
  }
215
 
#endif
216
 
  pthread_mutex_unlock(&share->intern_lock);
217
 
#if defined(FULL_LOG) || defined(_lint)
218
 
  lock_type|=(int) (flag << 8);         /* Set bit to set if real lock */
219
 
  myisam_log_command(MI_LOG_LOCK,info,(unsigned char*) &lock_type,sizeof(lock_type),
220
 
                     error);
221
 
#endif
222
 
  return(error);
223
 
} /* mi_lock_database */
224
 
 
225
 
 
226
 
/****************************************************************************
227
 
  The following functions are called by thr_lock() in threaded applications
228
 
****************************************************************************/
229
 
 
230
 
/*
231
 
  Create a copy of the current status for the table
232
 
 
233
 
  SYNOPSIS
234
 
    mi_get_status()
235
 
    param               Pointer to Myisam handler
236
 
    concurrent_insert   Set to 1 if we are going to do concurrent inserts
237
 
                        (THR_WRITE_CONCURRENT_INSERT was used)
238
 
*/
239
 
 
240
 
void mi_get_status(void* param, int concurrent_insert)
241
 
{
242
 
  MI_INFO *info=(MI_INFO*) param;
243
 
 
244
 
  info->save_state=info->s->state.state;
245
 
  info->state= &info->save_state;
246
 
  info->append_insert_at_end= concurrent_insert;
247
 
  return;
248
 
}
249
 
 
250
 
 
251
 
void mi_update_status(void* param)
252
 
{
253
 
  MI_INFO *info=(MI_INFO*) param;
254
 
  /*
255
 
    Because someone may have closed the table we point at, we only
256
 
    update the state if its our own state.  This isn't a problem as
257
 
    we are always pointing at our own lock or at a read lock.
258
 
    (This is enforced by thr_multi_lock.c)
259
 
  */
260
 
  if (info->state == &info->save_state)
261
 
  {
262
 
    info->s->state.state= *info->state;
263
 
    info->state= &info->s->state.state;
264
 
  }
265
 
  info->append_insert_at_end= 0;
266
 
 
267
 
  /*
268
 
    We have to flush the write cache here as other threads may start
269
 
    reading the table before mi_lock_database() is called
270
 
  */
271
 
  if (info->opt_flag & WRITE_CACHE_USED)
272
 
  {
273
 
    if (end_io_cache(&info->rec_cache))
274
 
    {
275
 
      mi_print_error(info->s, HA_ERR_CRASHED);
276
 
      mi_mark_crashed(info);
277
 
    }
278
 
    info->opt_flag&= ~WRITE_CACHE_USED;
279
 
  }
280
 
}
281
 
 
282
 
 
283
 
void mi_restore_status(void *param)
284
 
{
285
 
  MI_INFO *info= (MI_INFO*) param;
286
 
  info->state= &info->s->state.state;
287
 
  info->append_insert_at_end= 0;
288
 
}
289
 
 
290
 
 
291
 
void mi_copy_status(void* to,void *from)
292
 
{
293
 
  ((MI_INFO*) to)->state= &((MI_INFO*) from)->save_state;
294
 
}
295
 
 
296
 
 
297
 
/*
298
 
  Check if should allow concurrent inserts
299
 
 
300
 
  IMPLEMENTATION
301
 
    Allow concurrent inserts if we don't have a hole in the table or
302
 
    if there is no active write lock and there is active read locks and
303
 
    myisam_concurrent_insert == 2. In this last case the new
304
 
    row('s) are inserted at end of file instead of filling up the hole.
305
 
 
306
 
    The last case is to allow one to inserts into a heavily read-used table
307
 
    even if there is holes.
308
 
 
309
 
  NOTES
310
 
    If there is a an rtree indexes in the table, concurrent inserts are
311
 
    disabled in mi_open()
312
 
 
313
 
  RETURN
314
 
    0  ok to use concurrent inserts
315
 
    1  not ok
316
 
*/
317
 
 
318
 
bool mi_check_status(void *param)
319
 
{
320
 
  MI_INFO *info=(MI_INFO*) param;
321
 
  /*
322
 
    The test for w_locks == 1 is here because this thread has already done an
323
 
    external lock (in other words: w_locks == 1 means no other threads has
324
 
    a write lock)
325
 
  */
326
 
  return (bool) !(info->s->state.dellink == HA_OFFSET_ERROR ||
327
 
                     (myisam_concurrent_insert == 2 && info->s->r_locks &&
328
 
                      info->s->w_locks == 1));
329
 
}
330
 
 
331
 
 
332
 
/****************************************************************************
333
 
 ** functions to read / write the state
334
 
****************************************************************************/
335
 
 
336
 
int _mi_readinfo(register MI_INFO *info, int lock_type, int check_keybuffer)
337
 
{
338
 
  if (info->lock_type == F_UNLCK)
339
 
  {
340
 
    MYISAM_SHARE *share=info->s;
341
 
    if (!share->tot_locks)
342
 
    {
343
 
      if (mi_state_info_read_dsk(share->kfile, &share->state, 1))
344
 
      {
345
 
        int error=errno ? errno : -1;
346
 
        errno=error;
347
 
        return(1);
348
 
      }
349
 
    }
350
 
    if (check_keybuffer)
351
 
      _mi_test_if_changed(info);
352
 
  }
353
 
  else if (lock_type == F_WRLCK && info->lock_type == F_RDLCK)
354
 
  {
355
 
    errno=EACCES;                               /* Not allowed to change */
356
 
    return(-1);                         /* when have read_lock() */
357
 
  }
358
 
  return(0);
359
 
} /* _mi_readinfo */
360
 
 
361
 
 
362
 
/*
363
 
  Every isam-function that uppdates the isam-database MUST end with this
364
 
  request
365
 
*/
366
 
 
367
 
int _mi_writeinfo(register MI_INFO *info, uint32_t operation)
368
 
{
369
 
  int error,olderror;
370
 
  MYISAM_SHARE *share=info->s;
371
 
 
372
 
  error=0;
373
 
  if (share->tot_locks == 0)
374
 
  {
375
 
    olderror=errno;                     /* Remember last error */
376
 
    if (operation)
377
 
    {                                   /* Two threads can't be here */
378
 
      share->state.process= share->last_process=   share->this_process;
379
 
      share->state.unique=  info->last_unique=     info->this_unique;
380
 
      share->state.update_count= info->last_loop= ++info->this_loop;
381
 
      if ((error=mi_state_info_write(share->kfile, &share->state, 1)))
382
 
        olderror=errno;
383
 
    }
384
 
    errno=olderror;
385
 
  }
386
 
  else if (operation)
387
 
    share->changed= 1;                  /* Mark keyfile changed */
388
 
  return(error);
389
 
} /* _mi_writeinfo */
390
 
 
391
 
 
392
 
        /* Test if someone has changed the database */
393
 
        /* (Should be called after readinfo) */
394
 
 
395
 
int _mi_test_if_changed(register MI_INFO *info)
396
 
{
397
 
  MYISAM_SHARE *share=info->s;
398
 
  if (share->state.process != share->last_process ||
399
 
      share->state.unique  != info->last_unique ||
400
 
      share->state.update_count != info->last_loop)
401
 
  {                                             /* Keyfile has changed */
402
 
    if (share->state.process != share->this_process)
403
 
      flush_key_blocks(share->key_cache, share->kfile, FLUSH_RELEASE);
404
 
    share->last_process=share->state.process;
405
 
    info->last_unique=  share->state.unique;
406
 
    info->last_loop=    share->state.update_count;
407
 
    info->update|=      HA_STATE_WRITTEN;       /* Must use file on next */
408
 
    info->data_changed= 1;                      /* For mi_is_changed */
409
 
    return 1;
410
 
  }
411
 
  return (!(info->update & HA_STATE_AKTIV) ||
412
 
          (info->update & (HA_STATE_WRITTEN | HA_STATE_DELETED |
413
 
                           HA_STATE_KEY_CHANGED)));
414
 
} /* _mi_test_if_changed */
415
 
 
416
 
 
417
 
/*
418
 
  Put a mark in the .MYI file that someone is updating the table
419
 
 
420
 
 
421
 
  DOCUMENTATION
422
 
 
423
 
  state.open_count in the .MYI file is used the following way:
424
 
  - For the first change of the .MYI file in this process open_count is
425
 
    incremented by mi_mark_file_change(). (We have a write lock on the file
426
 
    when this happens)
427
 
  - In mi_close() it's decremented by _mi_decrement_open_count() if it
428
 
    was incremented in the same process.
429
 
 
430
 
  This mean that if we are the only process using the file, the open_count
431
 
  tells us if the MYISAM file wasn't properly closed.*/
432
 
 
433
 
 
434
 
int _mi_mark_file_changed(MI_INFO *info)
435
 
{
436
 
  unsigned char buff[3];
437
 
  register MYISAM_SHARE *share=info->s;
438
 
 
439
 
  if (!(share->state.changed & STATE_CHANGED) || ! share->global_changed)
440
 
  {
441
 
    share->state.changed|=(STATE_CHANGED | STATE_NOT_ANALYZED |
442
 
                           STATE_NOT_OPTIMIZED_KEYS);
443
 
    if (!share->global_changed)
444
 
    {
445
 
      share->global_changed=1;
446
 
      share->state.open_count++;
447
 
    }
448
 
    if (!share->temporary)
449
 
    {
450
 
      mi_int2store(buff,share->state.open_count);
451
 
      buff[2]=1;                                /* Mark that it's changed */
452
 
      return(my_pwrite(share->kfile,buff,sizeof(buff),
453
 
                            sizeof(share->state.header),
454
 
                            MYF(MY_NABP)));
455
 
    }
456
 
  }
457
 
  return(0);
458
 
}
459
 
 
460
 
 
461
 
/*
462
 
  This is only called by close or by extra(HA_FLUSH) if the OS has the pwrite()
463
 
  call.  In these context the following code should be safe!
464
 
 */
465
 
 
466
 
int _mi_decrement_open_count(MI_INFO *info)
467
 
{
468
 
  unsigned char buff[2];
469
 
  register MYISAM_SHARE *share=info->s;
470
 
  int lock_error=0,write_error=0;
471
 
  if (share->global_changed)
472
 
  {
473
 
    uint32_t old_lock=info->lock_type;
474
 
    share->global_changed=0;
475
 
    lock_error=mi_lock_database(info,F_WRLCK);
476
 
    /* Its not fatal even if we couldn't get the lock ! */
477
 
    if (share->state.open_count > 0)
478
 
    {
479
 
      share->state.open_count--;
480
 
      mi_int2store(buff,share->state.open_count);
481
 
      write_error=my_pwrite(share->kfile,buff,sizeof(buff),
482
 
                            sizeof(share->state.header),
483
 
                            MYF(MY_NABP));
484
 
    }
485
 
    if (!lock_error)
486
 
      lock_error=mi_lock_database(info,old_lock);
487
 
  }
488
 
  return test(lock_error || write_error);
489
 
}