← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_page.c

  • Committer: Monty Taylor
  • Date: 2008-07-16 19:10:24 UTC
  • mfrom: (51.1.127 remove-dbug)
  • mto: This revision was merged to the branch mainline in revision 176.
  • Revision ID: monty@inaugust.com-20080716191024-prjgoh7fbri7rx26
Merged from remove-dbug.

Show diffs side-by-side

added added

removed removed

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