← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_page.c

  • Committer: Brian Aker
  • Date: 2008-07-07 14:25:25 UTC
  • mto: (77.1.25 codestyle)
  • mto: This revision was merged to the branch mainline in revision 82.
  • Revision ID: brian@tangent.org-20080707142525-xzy2nl3ie2ebwfln
LL() cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_page.c
19
19
 
20
20
        /* Fetch a key-page in memory */
21
21
 
22
 
unsigned char *_mi_fetch_keypage(register MI_INFO *info, MI_KEYDEF *keyinfo,
 
22
uchar *_mi_fetch_keypage(register MI_INFO *info, MI_KEYDEF *keyinfo,
23
23
                         my_off_t page, int level, 
24
 
                         unsigned char *buff, int return_buffer)
 
24
                         uchar *buff, int return_buffer)
25
25
{
26
 
  unsigned char *tmp;
27
 
  uint32_t page_size;
 
26
  uchar *tmp;
 
27
  uint page_size;
 
28
  DBUG_ENTER("_mi_fetch_keypage");
 
29
  DBUG_PRINT("enter",("page: %ld", (long) page));
28
30
 
29
 
  tmp=(unsigned char*) key_cache_read(info->s->key_cache,
30
 
                             info->s->kfile, page, level, (unsigned char*) buff,
 
31
  tmp=(uchar*) key_cache_read(info->s->key_cache,
 
32
                             info->s->kfile, page, level, (uchar*) buff,
31
33
                             (uint) keyinfo->block_length,
32
34
                             (uint) keyinfo->block_length,
33
35
                             return_buffer);
35
37
    info->buff_used=1;
36
38
  else if (!tmp)
37
39
  {
 
40
    DBUG_PRINT("error",("Got errno: %d from key_cache_read",my_errno));
38
41
    info->last_keypage=HA_OFFSET_ERROR;
39
42
    mi_print_error(info->s, HA_ERR_CRASHED);
40
43
    my_errno=HA_ERR_CRASHED;
41
 
    return(0);
 
44
    DBUG_RETURN(0);
42
45
  }
43
46
  info->last_keypage=page;
44
47
  page_size=mi_getint(tmp);
45
48
  if (page_size < 4 || page_size > keyinfo->block_length)
46
49
  {
 
50
    DBUG_PRINT("error",("page %lu had wrong page length: %u",
 
51
                        (ulong) page, page_size));
 
52
    DBUG_DUMP("page", (uchar*) tmp, keyinfo->block_length);
47
53
    info->last_keypage = HA_OFFSET_ERROR;
48
54
    mi_print_error(info->s, HA_ERR_CRASHED);
49
55
    my_errno = HA_ERR_CRASHED;
50
56
    tmp = 0;
51
57
  }
52
 
  return(tmp);
 
58
  DBUG_RETURN(tmp);
53
59
} /* _mi_fetch_keypage */
54
60
 
55
61
 
56
62
        /* Write a key-page on disk */
57
63
 
58
64
int _mi_write_keypage(register MI_INFO *info, register MI_KEYDEF *keyinfo,
59
 
                      my_off_t page, int level, unsigned char *buff)
 
65
                      my_off_t page, int level, uchar *buff)
60
66
{
61
 
  register uint32_t length;
 
67
  register uint length;
 
68
  DBUG_ENTER("_mi_write_keypage");
62
69
 
63
70
#ifndef FAST                                    /* Safety check */
64
71
  if (page < info->s->base.keystart ||
65
72
      page+keyinfo->block_length > info->state->key_file_length ||
66
73
      (page & (MI_MIN_KEY_BLOCK_LENGTH-1)))
67
74
  {
 
75
    DBUG_PRINT("error",("Trying to write inside key status region: key_start: %lu  length: %lu  page: %lu",
 
76
                        (long) info->s->base.keystart,
 
77
                        (long) info->state->key_file_length,
 
78
                        (long) page));
68
79
    my_errno=EINVAL;
69
 
    return((-1));
 
80
    DBUG_RETURN((-1));
70
81
  }
 
82
  DBUG_PRINT("page",("write page at: %lu",(long) page));
 
83
  DBUG_DUMP("buff",(uchar*) buff,mi_getint(buff));
71
84
#endif
72
85
 
73
86
  if ((length=keyinfo->block_length) > IO_SIZE*2 &&
76
89
#ifdef HAVE_purify
77
90
  {
78
91
    length=mi_getint(buff);
79
 
    memset(buff+length, 0, keyinfo->block_length-length);
 
92
    bzero((uchar*) buff+length,keyinfo->block_length-length);
80
93
    length=keyinfo->block_length;
81
94
  }
82
95
#endif
83
 
  return((key_cache_write(info->s->key_cache,
84
 
                         info->s->kfile,page, level, (unsigned char*) buff,length,
 
96
  DBUG_RETURN((key_cache_write(info->s->key_cache,
 
97
                         info->s->kfile,page, level, (uchar*) buff,length,
85
98
                         (uint) keyinfo->block_length,
86
99
                         (int) ((info->lock_type != F_UNLCK) ||
87
100
                                info->s->delay_key_write))));
94
107
                int level)
95
108
{
96
109
  my_off_t old_link;
97
 
  unsigned char buff[8];
 
110
  uchar buff[8];
 
111
  DBUG_ENTER("_mi_dispose");
 
112
  DBUG_PRINT("enter",("pos: %ld", (long) pos));
98
113
 
99
114
  old_link= info->s->state.key_del[keyinfo->block_size_index];
100
115
  info->s->state.key_del[keyinfo->block_size_index]= pos;
101
116
  mi_sizestore(buff,old_link);
102
117
  info->s->state.changed|= STATE_NOT_SORTED_PAGES;
103
 
  return(key_cache_write(info->s->key_cache,
 
118
  DBUG_RETURN(key_cache_write(info->s->key_cache,
104
119
                              info->s->kfile, pos , level, buff,
105
120
                              sizeof(buff),
106
121
                              (uint) keyinfo->block_length,
113
128
my_off_t _mi_new(register MI_INFO *info, MI_KEYDEF *keyinfo, int level)
114
129
{
115
130
  my_off_t pos;
116
 
  unsigned char buff[8];
 
131
  uchar buff[8];
 
132
  DBUG_ENTER("_mi_new");
117
133
 
118
134
  if ((pos= info->s->state.key_del[keyinfo->block_size_index]) ==
119
135
      HA_OFFSET_ERROR)
122
138
        info->s->base.max_key_file_length - keyinfo->block_length)
123
139
    {
124
140
      my_errno=HA_ERR_INDEX_FILE_FULL;
125
 
      return(HA_OFFSET_ERROR);
 
141
      DBUG_RETURN(HA_OFFSET_ERROR);
126
142
    }
127
143
    pos=info->state->key_file_length;
128
144
    info->state->key_file_length+= keyinfo->block_length;
139
155
      info->s->state.key_del[keyinfo->block_size_index]= mi_sizekorr(buff);
140
156
  }
141
157
  info->s->state.changed|= STATE_NOT_SORTED_PAGES;
142
 
  return(pos);
 
158
  DBUG_PRINT("exit",("Pos: %ld",(long) pos));
 
159
  DBUG_RETURN(pos);
143
160
} /* _mi_new */