开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
myisamlog.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：22k
源码类别：

MySQL数据库

开发平台：

Visual C++

myisamlog.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* write whats in isam.log */
  19. #ifndef USE_MY_FUNC
  20. #define USE_MY_FUNC
  21. #endif
  23. #include "myisamdef.h"
  24. #include <my_tree.h>
  25. #include <stdarg.h>
  26. #ifdef HAVE_GETRUSAGE
  27. #include <sys/resource.h>
  28. #endif
  30. #define FILENAME(A) (A ? A->show_name : "Unknown")
  32. struct file_info {
  33.   long process;
  34.   int  filenr,id;
  35.   uint rnd;
  36.   my_string name,show_name,record;
  37.   MI_INFO *isam;
  38.   bool closed,used;
  39.   ulong accessed;
  40. };
  42. struct test_if_open_param {
  43.   my_string name;
  44.   int max_id;
  45. };
  47. struct st_access_param
  48. {
  49.   ulong min_accessed;
  50.   struct file_info *found;
  51. };
  53. #define NO_FILEPOS (ulong) ~0L
  55. extern int main(int argc,char * *argv);
  56. static void get_options(int *argc,char ***argv);
  57. static int examine_log(my_string file_name,char **table_names);
  58. static int read_string(IO_CACHE *file,gptr *to,uint length);
  59. static int file_info_compare(void *cmp_arg, void *a,void *b);
  60. static int test_if_open(struct file_info *key,element_count count,
  61. struct test_if_open_param *param);
  62. static void fix_blob_pointers(MI_INFO *isam,byte *record);
  63. static int test_when_accessed(struct file_info *key,element_count count,
  64.       struct st_access_param *access_param);
  65. static void file_info_free(struct file_info *info);
  66. static int close_some_file(TREE *tree);
  67. static int reopen_closed_file(TREE *tree,struct file_info *file_info);
  68. static int find_record_with_key(struct file_info *file_info,byte *record);
  69. static void printf_log(const char *str,...);
  70. static bool cmp_filename(struct file_info *file_info,my_string name);
  72. static uint verbose=0,update=0,test_info=0,max_files=0,re_open_count=0,
  73.   recover=0,prefix_remove=0,opt_processes=0;
  74. static my_string log_filename=0,filepath=0,write_filename=0,record_pos_file=0;
  75. static ulong com_count[10][3],number_of_commands=(ulong) ~0L,
  76.      isamlog_process;
  77. static my_off_t isamlog_filepos,start_offset=0,record_pos= HA_OFFSET_ERROR;
  78. static const char *command_name[]=
  79. {"open","write","update","delete","close","extra","lock","re-open",
  80.  "delete-all", NullS};
  83. int main(int argc, char **argv)
  84. {
  85.   int error,i,first;
  86.   ulong total_count,total_error,total_recover;
  87.   MY_INIT(argv[0]);
  89.   log_filename=myisam_log_filename;
  90.   get_options(&argc,&argv);
  91.   /* Number of MyISAM files we can have open at one time */
  92.   max_files= (my_set_max_open_files(min(max_files,8))-6)/2;
  93.   if (update)
  94.     printf("Trying to %s MyISAM files according to log '%s'n",
  95.    (recover ? "recover" : "update"),log_filename);
  96.   error= examine_log(log_filename,argv);
  97.   if (update && ! error)
  98.     puts("Tables updated successfully");
  99.   total_count=total_error=total_recover=0;
  100.   for (i=first=0 ; command_name[i] ; i++)
  101.   {
  102.     if (com_count[i][0])
  103.     {
  104.       if (!first++)
  105.       {
  106. if (verbose || update)
  107.   puts("");
  108. puts("Commands   Used count    Errors   Recover errors");
  109.       }
  110.       printf("%-12s%9ld%10ld%17ldn",command_name[i],com_count[i][0],
  111.      com_count[i][1],com_count[i][2]);
  112.       total_count+=com_count[i][0];
  113.       total_error+=com_count[i][1];
  114.       total_recover+=com_count[i][2];
  115.     }
  116.   }
  117.   if (total_count)
  118.     printf("%-12s%9ld%10ld%17ldn","Total",total_count,total_error,
  119.    total_recover);
  120.   if (re_open_count)
  121.     printf("Had to do %d re-open because of too few possibly open filesn",
  122.    re_open_count);
  123.   VOID(mi_panic(HA_PANIC_CLOSE));
  124.   my_free_open_file_info();
  125.   my_end(test_info ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  126.   exit(error);
  127.   return 0; /* No compiler warning */
  128. } /* main */
  131. static void get_options(register int *argc, register char ***argv)
  132. {
  133.   int help,version;
  134.   const char *pos,*usage;
  135.   char option;
  137.   help=0;
  138.   usage="Usage: %s [-?iruvDIV] [-c #] [-f #] [-F filepath/] [-o #] [-R file recordpos] [-w write_file] [log-filename [table ...]] n";
  139.   pos="";
  141.   while (--*argc > 0 && *(pos = *(++*argv)) == '-' ) {
  142.     while (*++pos)
  143.     {
  144.       version=0;
  145.       switch((option=*pos)) {
  146.       case '#':
  147. DBUG_PUSH (++pos);
  148. pos=" "; /* Skip rest of arg */
  149. break;
  150.       case 'c':
  151. if (! *++pos)
  152. {
  153.   if (!--*argc)
  154.     goto err;
  155.   else
  156.     pos= *(++*argv);
  157. }
  158. number_of_commands=(ulong) atol(pos);
  159. pos=" ";
  160. break;
  161.       case 'u':
  162. update=1;
  163. break;
  164.       case 'f':
  165. if (! *++pos)
  166. {
  167.   if (!--*argc)
  168.     goto err;
  169.   else
  170.     pos= *(++*argv);
  171. }
  172. max_files=(uint) atoi(pos);
  173. pos=" ";
  174. break;
  175.       case 'i':
  176. test_info=1;
  177. break;
  178.       case 'o':
  179. if (! *++pos)
  180. {
  181.   if (!--*argc)
  182.     goto err;
  183.   else
  184.     pos= *(++*argv);
  185. }
  186. start_offset=(my_off_t) strtoll(pos,NULL,10);
  187. pos=" ";
  188. break;
  189.       case 'p':
  190. if (! *++pos)
  191. {
  192.   if (!--*argc)
  193.     goto err;
  194.   else
  195.     pos= *(++*argv);
  196. }
  197. prefix_remove=atoi(pos);
  198. break;
  199.       case 'r':
  200. update=1;
  201. recover++;
  202. break;
  203.       case 'P':
  204. opt_processes=1;
  205. break;
  206.       case 'R':
  207. if (! *++pos)
  208. {
  209.   if (!--*argc)
  210.     goto err;
  211.   else
  212.     pos= *(++*argv);
  213. }
  214. record_pos_file=(char*) pos;
  215. if (!--*argc)
  216.   goto err;
  217. record_pos=(my_off_t) strtoll(*(++*argv),NULL,10);
  218. pos=" ";
  219. break;
  220.       case 'v':
  221. verbose++;
  222. break;
  223.       case 'w':
  224. if (! *++pos)
  225. {
  226.   if (!--*argc)
  227.     goto err;
  228.   else
  229.     pos= *(++*argv);
  230. }
  231. write_filename=(char*) pos;
  232. pos=" ";
  233. break;
  234.       case 'F':
  235. if (! *++pos)
  236. {
  237.   if (!--*argc)
  238.     goto err;
  239.   else
  240.     pos= *(++*argv);
  241. }
  242. filepath= (char*) pos;
  243. pos=" ";
  244. break;
  245.       case 'V':
  246. version=1;
  247. /* Fall through */
  248.       case 'I':
  249.       case '?':
  250. #include <help_start.h>
  251. printf("%s  Ver 1.4 for %s at %sn",my_progname,SYSTEM_TYPE,
  252.        MACHINE_TYPE);
  253. puts("By Monty, for your professional usen");
  254. if (version)
  255.   break;
  256. puts("Write info about whats in a MyISAM log file.");
  257. printf("If no file name is given %s is usedn",log_filename);
  258. puts("");
  259. printf(usage,my_progname);
  260. puts("");
  261. puts("Options: -? or -I "Info"     -V "version"   -c "do only # commands"");
  262. puts("         -f "max open files" -F "filepath"  -i "extra info"");
  263. puts("         -o "offset"         -p # "remove # components from path"");
  264. puts("         -r "recover"        -R "file recordposition"");
  265. puts("         -u "update"         -v "verbose"   -w "write file"");
  266. puts("         -D "myisam compiled with DBUG"   -P "processes"");
  267. puts("nOne can give a second and a third '-v' for more verbose.");
  268. puts("Normaly one does a update (-u).");
  269. puts("If a recover is done all writes and all possibly updates and deletes is donenand errors are only counted.");
  270. puts("If one gives table names as arguments only these tables will be updatedn");
  271. help=1;
  272. #include <help_end.h>
  273. break;
  274.       default:
  275. printf("illegal option: "-%c"n",*pos);
  276. break;
  277.       }
  278.     }
  279.   }
  280.   if (! *argc)
  281.   {
  282.     if (help)
  283.     exit(0);
  284.     (*argv)++;
  285.   }
  286.   if (*argc >= 1)
  287.   {
  288.     log_filename=(char*) pos;
  289.     (*argc)--;
  290.     (*argv)++;
  291.   }
  292.   return;
  293.  err:
  294.   VOID(fprintf(stderr,"option "%c" used without or with wrong argumentn",
  295.        option));
  296.   exit(1);
  297. }
  300. static int examine_log(my_string file_name, char **table_names)
  301. {
  302.   uint command,result,files_open;
  303.   ulong access_time,length;
  304.   my_off_t filepos;
  305.   int lock_command,mi_result;
  306.   char isam_file_name[FN_REFLEN],llbuff[21],llbuff2[21];
  307.   uchar head[20];
  308.   gptr buff;
  309.   struct test_if_open_param open_param;
  310.   IO_CACHE cache;
  311.   File file;
  312.   FILE *write_file;
  313.   enum ha_extra_function extra_command;
  314.   TREE tree;
  315.   struct file_info file_info,*curr_file_info;
  316.   DBUG_ENTER("examine_log");
  318.   if ((file=my_open(file_name,O_RDONLY,MYF(MY_WME))) < 0)
  319.     DBUG_RETURN(1);
  320.   write_file=0;
  321.   if (write_filename)
  322.   {
  323.     if (!(write_file=my_fopen(write_filename,O_WRONLY,MYF(MY_WME))))
  324.     {
  325.       my_close(file,MYF(0));
  326.       DBUG_RETURN(1);
  327.     }
  328.   }
  330.   init_io_cache(&cache,file,0,READ_CACHE,start_offset,0,MYF(0));
  331.   bzero((gptr) com_count,sizeof(com_count));
  332.   init_tree(&tree,0,0,sizeof(file_info),(qsort_cmp2) file_info_compare,1,
  333.     (tree_element_free) file_info_free, NULL);
  334.   VOID(init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,KEY_CACHE_SIZE,
  335.                       0, 0));
  337.   files_open=0; access_time=0;
  338.   while (access_time++ != number_of_commands &&
  339.  !my_b_read(&cache,(byte*) head,9))
  340.   {
  341.     isamlog_filepos=my_b_tell(&cache)-9L;
  342.     file_info.filenr= mi_uint2korr(head+1);
  343.     isamlog_process=file_info.process=(long) mi_uint4korr(head+3);
  344.     if (!opt_processes)
  345.       file_info.process=0;
  346.     result= mi_uint2korr(head+7);
  347.     if ((curr_file_info=(struct file_info*) tree_search(&tree, &file_info,
  348. tree.custom_arg)))
  349.     {
  350.       curr_file_info->accessed=access_time;
  351.       if (update && curr_file_info->used && curr_file_info->closed)
  352.       {
  353. if (reopen_closed_file(&tree,curr_file_info))
  354. {
  355.   command=sizeof(com_count)/sizeof(com_count[0][0])/3;
  356.   result=0;
  357.   goto com_err;
  358. }
  359.       }
  360.     }
  361.     command=(uint) head[0];
  362.     if (command < sizeof(com_count)/sizeof(com_count[0][0])/3 &&
  363. (!table_names[0] || (curr_file_info && curr_file_info->used)))
  364.     {
  365.       com_count[command][0]++;
  366.       if (result)
  367. com_count[command][1]++;
  368.     }
  369.     switch ((enum myisam_log_commands) command) {
  370.     case MI_LOG_OPEN:
  371.       if (!table_names[0])
  372.       {
  373. com_count[command][0]--; /* Must be counted explicite */
  374. if (result)
  375.   com_count[command][1]--;
  376.       }
  378.       if (curr_file_info)
  379. printf("nWarning: %s is opened with same process and filenumbernMaybe you should use the -P option ?n",
  380.        curr_file_info->show_name);
  381.       if (my_b_read(&cache,(byte*) head,2))
  382. goto err;
  383.       file_info.name=0;
  384.       file_info.show_name=0;
  385.       file_info.record=0;
  386.       if (read_string(&cache,(gptr*) &file_info.name,
  387.       (uint) mi_uint2korr(head)))
  388. goto err;
  389.       {
  390. uint i;
  391. char *pos,*to;
  393. /* Fix if old DOS files to new format */
  394. for (pos=file_info.name; (pos=strchr(pos,'\')) ; pos++)
  395.   *pos= '/';
  397. pos=file_info.name;
  398. for (i=0 ; i < prefix_remove ; i++)
  399. {
  400.   char *next;
  401.   if (!(next=strchr(pos,'/')))
  402.     break;
  403.   pos=next+1;
  404. }
  405. to=isam_file_name;
  406. if (filepath)
  407.   to=convert_dirname(isam_file_name,filepath,NullS);
  408. strmov(to,pos);
  409. fn_ext(isam_file_name)[0]=0; /* Remove extension */
  410.       }
  411.       open_param.name=file_info.name;
  412.       open_param.max_id=0;
  413.       VOID(tree_walk(&tree,(tree_walk_action) test_if_open,(void*) &open_param,
  414.      left_root_right));
  415.       file_info.id=open_param.max_id+1;
  416.       /*
  417.        * In the line below +10 is added to accomodate '<' and '>' chars
  418.        * plus '' at the end, so that there is place for 7 digits.
  419.        * It is  improbable that same table can have that many entries in 
  420.        * the table cache.
  421.        * The additional space is needed for the sprintf commands two lines
  422.        * below.
  423.        */ 
  424.       file_info.show_name=my_memdup(isam_file_name,
  425.     (uint) strlen(isam_file_name)+10,
  426.     MYF(MY_WME));
  427.       if (file_info.id > 1)
  428. sprintf(strend(file_info.show_name),"<%d>",file_info.id);
  429.       file_info.closed=1;
  430.       file_info.accessed=access_time;
  431.       file_info.used=1;
  432.       if (table_names[0])
  433.       {
  434. char **name;
  435. file_info.used=0;
  436. for (name=table_names ; *name ; name++)
  437. {
  438.   if (!strcmp(*name,isam_file_name))
  439.     file_info.used=1; /* Update/log only this */
  440. }
  441.       }
  442.       if (update && file_info.used)
  443.       {
  444. if (files_open >= max_files)
  445. {
  446.   if (close_some_file(&tree))
  447.     goto com_err;
  448.   files_open--;
  449. }
  450. if (!(file_info.isam= mi_open(isam_file_name,O_RDWR,
  451.       HA_OPEN_WAIT_IF_LOCKED)))
  452.   goto com_err;
  453. if (!(file_info.record=my_malloc(file_info.isam->s->base.reclength,
  454.  MYF(MY_WME))))
  455.   goto end;
  456. files_open++;
  457. file_info.closed=0;
  458.       }
  459.       VOID(tree_insert(&tree, (gptr) &file_info, 0, tree.custom_arg));
  460.       if (file_info.used)
  461.       {
  462. if (verbose && !record_pos_file)
  463.   printf_log("%s: open -> %d",file_info.show_name, file_info.filenr);
  464. com_count[command][0]++;
  465. if (result)
  466.   com_count[command][1]++;
  467.       }
  468.       break;
  469.     case MI_LOG_CLOSE:
  470.       if (verbose && !record_pos_file &&
  471.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  472. printf_log("%s: %s -> %d",FILENAME(curr_file_info),
  473.        command_name[command],result);
  474.       if (curr_file_info)
  475.       {
  476. if (!curr_file_info->closed)
  477.   files_open--;
  478. VOID(tree_delete(&tree, (gptr) curr_file_info, tree.custom_arg));
  479.       }
  480.       break;
  481.     case MI_LOG_EXTRA:
  482.       if (my_b_read(&cache,(byte*) head,1))
  483. goto err;
  484.       extra_command=(enum ha_extra_function) head[0];
  485.       if (verbose && !record_pos_file &&
  486.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  487. printf_log("%s: %s(%d) -> %d",FILENAME(curr_file_info),
  488.    command_name[command], (int) extra_command,result);
  489.       if (update && curr_file_info && !curr_file_info->closed)
  490.       {
  491. if (mi_extra(curr_file_info->isam, extra_command, 0) != (int) result)
  492. {
  493.   fflush(stdout);
  494.   VOID(fprintf(stderr,
  495.        "Warning: error %d, expected %d on command %s at %sn",
  496.        my_errno,result,command_name[command],
  497.        llstr(isamlog_filepos,llbuff)));
  498.   fflush(stderr);
  499. }
  500.       }
  501.       break;
  502.     case MI_LOG_DELETE:
  503.       if (my_b_read(&cache,(byte*) head,8))
  504. goto err;
  505.       filepos=mi_sizekorr(head);
  506.       if (verbose && (!record_pos_file ||
  507.       ((record_pos == filepos || record_pos == NO_FILEPOS) &&
  508.        !cmp_filename(curr_file_info,record_pos_file))) &&
  509.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  510. printf_log("%s: %s at %ld -> %d",FILENAME(curr_file_info),
  511.    command_name[command],(long) filepos,result);
  512.       if (update && curr_file_info && !curr_file_info->closed)
  513.       {
  514. if (mi_rrnd(curr_file_info->isam,curr_file_info->record,filepos))
  515. {
  516.   if (!recover)
  517.     goto com_err;
  518.   if (verbose)
  519.     printf_log("error: Didn't find row to delete with mi_rrnd");
  520.   com_count[command][2]++; /* Mark error */
  521. }
  522. mi_result=mi_delete(curr_file_info->isam,curr_file_info->record);
  523. if ((mi_result == 0 && result) ||
  524.     (mi_result && (uint) my_errno != result))
  525. {
  526.   if (!recover)
  527.     goto com_err;
  528.   if (mi_result)
  529.     com_count[command][2]++; /* Mark error */
  530.   if (verbose)
  531.     printf_log("error: Got result %d from mi_delete instead of %d",
  532.        mi_result, result);
  533. }
  534.       }
  535.       break;
  536.     case MI_LOG_WRITE:
  537.     case MI_LOG_UPDATE:
  538.       if (my_b_read(&cache,(byte*) head,12))
  539. goto err;
  540.       filepos=mi_sizekorr(head);
  541.       length=mi_uint4korr(head+8);
  542.       buff=0;
  543.       if (read_string(&cache,&buff,(uint) length))
  544. goto err;
  545.       if ((!record_pos_file ||
  546.   ((record_pos == filepos || record_pos == NO_FILEPOS) &&
  547.    !cmp_filename(curr_file_info,record_pos_file))) &&
  548.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  549.       {
  550. if (write_file &&
  551.     (my_fwrite(write_file,buff,length,MYF(MY_WAIT_IF_FULL | MY_NABP))))
  552.   goto end;
  553. if (verbose)
  554.   printf_log("%s: %s at %ld, length=%ld -> %d",
  555.      FILENAME(curr_file_info),
  556.      command_name[command], filepos,length,result);
  557.       }
  558.       if (update && curr_file_info && !curr_file_info->closed)
  559.       {
  560. if (curr_file_info->isam->s->base.blobs)
  561.   fix_blob_pointers(curr_file_info->isam,buff);
  562. if ((enum myisam_log_commands) command == MI_LOG_UPDATE)
  563. {
  564.   if (mi_rrnd(curr_file_info->isam,curr_file_info->record,filepos))
  565.   {
  566.     if (!recover)
  567.     {
  568.       result=0;
  569.       goto com_err;
  570.     }
  571.     if (verbose)
  572.       printf_log("error: Didn't find row to update with mi_rrnd");
  573.     if (recover == 1 || result ||
  574. find_record_with_key(curr_file_info,buff))
  575.     {
  576.       com_count[command][2]++; /* Mark error */
  577.       break;
  578.     }
  579.   }
  580.   mi_result=mi_update(curr_file_info->isam,curr_file_info->record,
  581.       buff);
  582.   if ((mi_result == 0 && result) ||
  583.       (mi_result && (uint) my_errno != result))
  584.   {
  585.     if (!recover)
  586.       goto com_err;
  587.     if (verbose)
  588.       printf_log("error: Got result %d from mi_update instead of %d",
  589.  mi_result, result);
  590.     if (mi_result)
  591.       com_count[command][2]++; /* Mark error */
  592.   }
  593. }
  594. else
  595. {
  596.   mi_result=mi_write(curr_file_info->isam,buff);
  597.   if ((mi_result == 0 && result) ||
  598.       (mi_result && (uint) my_errno != result))
  599.   {
  600.     if (!recover)
  601.       goto com_err;
  602.     if (verbose)
  603.       printf_log("error: Got result %d from mi_write instead of %d",
  604.  mi_result, result);
  605.     if (mi_result)
  606.       com_count[command][2]++; /* Mark error */
  607.   }
  608.   if (!recover && filepos != curr_file_info->isam->lastpos)
  609.   {
  610.     printf("error: Wrote at position: %s, should have been %s",
  611.    llstr(curr_file_info->isam->lastpos,llbuff),
  612.    llstr(filepos,llbuff2));
  613.     goto end;
  614.   }
  615. }
  616.       }
  617.       my_free(buff,MYF(0));
  618.       break;
  619.     case MI_LOG_LOCK:
  620.       if (my_b_read(&cache,(byte*) head,sizeof(lock_command)))
  621. goto err;
  622.       memcpy_fixed(&lock_command,head,sizeof(lock_command));
  623.       if (verbose && !record_pos_file &&
  624.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  625. printf_log("%s: %s(%d) -> %dn",FILENAME(curr_file_info),
  626.    command_name[command],lock_command,result);
  627.       if (update && curr_file_info && !curr_file_info->closed)
  628.       {
  629. if (mi_lock_database(curr_file_info->isam,lock_command) !=
  630.     (int) result)
  631.   goto com_err;
  632.       }
  633.       break;
  634.     case MI_LOG_DELETE_ALL:
  635.       if (verbose && !record_pos_file &&
  636.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  637. printf_log("%s: %s -> %dn",FILENAME(curr_file_info),
  638.    command_name[command],result);
  639.       break;
  640.     default:
  641.       fflush(stdout);
  642.       VOID(fprintf(stderr,
  643.    "Error: found unknown command %d in logfile, abortedn",
  644.    command));
  645.       fflush(stderr);
  646.       goto end;
  647.     }
  648.   }
  649.   end_key_cache(dflt_key_cache,1);
  650.   delete_tree(&tree);
  651.   VOID(end_io_cache(&cache));
  652.   VOID(my_close(file,MYF(0)));
  653.   if (write_file && my_fclose(write_file,MYF(MY_WME)))
  654.     DBUG_RETURN(1);
  655.   DBUG_RETURN(0);
  657.  err:
  658.   fflush(stdout);
  659.   VOID(fprintf(stderr,"Got error %d when reading from logfilen",my_errno));
  660.   fflush(stderr);
  661.   goto end;
  662.  com_err:
  663.   fflush(stdout);
  664.   VOID(fprintf(stderr,"Got error %d, expected %d on command %s at %sn",
  665.        my_errno,result,command_name[command],
  666.        llstr(isamlog_filepos,llbuff)));
  667.   fflush(stderr);
  668.  end:
  669.   end_key_cache(dflt_key_cache, 1);
  670.   delete_tree(&tree);
  671.   VOID(end_io_cache(&cache));
  672.   VOID(my_close(file,MYF(0)));
  673.   if (write_file)
  674.     VOID(my_fclose(write_file,MYF(MY_WME)));
  675.   DBUG_RETURN(1);
  676. }
  679. static int read_string(IO_CACHE *file, register gptr *to, register uint length)
  680. {
  681.   DBUG_ENTER("read_string");
  683.   if (*to)
  684.     my_free((gptr) *to,MYF(0));
  685.   if (!(*to= (gptr) my_malloc(length+1,MYF(MY_WME))) ||
  686.       my_b_read(file,(byte*) *to,length))
  687.   {
  688.     if (*to)
  689.       my_free(*to,MYF(0));
  690.     *to= 0;
  691.     DBUG_RETURN(1);
  692.   }
  693.   *((char*) *to+length)= '';
  694.   DBUG_RETURN (0);
  695. } /* read_string */
  698. static int file_info_compare(void* cmp_arg __attribute__((unused)),
  699.      void *a, void *b)
  700. {
  701.   long lint;
  703.   if ((lint=((struct file_info*) a)->process -
  704.        ((struct file_info*) b)->process))
  705.     return lint < 0L ? -1 : 1;
  706.   return ((struct file_info*) a)->filenr - ((struct file_info*) b)->filenr;
  707. }
  709. /* ARGSUSED */
  711. static int test_if_open (struct file_info *key,
  712.  element_count count __attribute__((unused)),
  713.  struct test_if_open_param *param)
  714. {
  715.   if (!strcmp(key->name,param->name) && key->id > param->max_id)
  716.     param->max_id=key->id;
  717.   return 0;
  718. }
  721. static void fix_blob_pointers(MI_INFO *info, byte *record)
  722. {
  723.   byte *pos;
  724.   MI_BLOB *blob,*end;
  726.   pos=record+info->s->base.reclength;
  727.   for (end=info->blobs+info->s->base.blobs, blob= info->blobs;
  728.        blob != end ;
  729.        blob++)
  730.   {
  731.     memcpy_fixed(record+blob->offset+blob->pack_length,&pos,sizeof(char*));
  732.     pos+=_mi_calc_blob_length(blob->pack_length,record+blob->offset);
  733.   }
  734. }
  736. /* close the file with hasn't been accessed for the longest time */
  737. /* ARGSUSED */
  739. static int test_when_accessed (struct file_info *key,
  740.        element_count count __attribute__((unused)),
  741.        struct st_access_param *access_param)
  742. {
  743.   if (key->accessed < access_param->min_accessed && ! key->closed)
  744.   {
  745.     access_param->min_accessed=key->accessed;
  746.     access_param->found=key;
  747.   }
  748.   return 0;
  749. }
  752. static void file_info_free(struct file_info *fileinfo)
  753. {
  754.   DBUG_ENTER("file_info_free");
  755.   if (update)
  756.   {
  757.     if (!fileinfo->closed)
  758.       VOID(mi_close(fileinfo->isam));
  759.     if (fileinfo->record)
  760.       my_free(fileinfo->record,MYF(0));
  761.   }
  762.   my_free(fileinfo->name,MYF(0));
  763.   my_free(fileinfo->show_name,MYF(0));
  764.   DBUG_VOID_RETURN;
  765. }
  769. static int close_some_file(TREE *tree)
  770. {
  771.   struct st_access_param access_param;
  773.   access_param.min_accessed=LONG_MAX;
  774.   access_param.found=0;
  776.   VOID(tree_walk(tree,(tree_walk_action) test_when_accessed,
  777.  (void*) &access_param,left_root_right));
  778.   if (!access_param.found)
  779.     return 1; /* No open file that is possibly to close */
  780.   if (mi_close(access_param.found->isam))
  781.     return 1;
  782.   access_param.found->closed=1;
  783.   return 0;
  784. }
  787. static int reopen_closed_file(TREE *tree, struct file_info *fileinfo)
  788. {
  789.   char name[FN_REFLEN];
  790.   if (close_some_file(tree))
  791.     return 1; /* No file to close */
  792.   strmov(name,fileinfo->show_name);
  793.   if (fileinfo->id > 1)
  794.     *strrchr(name,'<')=''; /* Remove "<id>" */
  796.   if (!(fileinfo->isam= mi_open(name,O_RDWR,HA_OPEN_WAIT_IF_LOCKED)))
  797.     return 1;
  798.   fileinfo->closed=0;
  799.   re_open_count++;
  800.   return 0;
  801. }
  803. /* Try to find record with uniq key */
  805. static int find_record_with_key(struct file_info *file_info, byte *record)
  806. {
  807.   uint key;
  808.   MI_INFO *info=file_info->isam;
  809.   uchar tmp_key[MI_MAX_KEY_BUFF];
  811.   for (key=0 ; key < info->s->base.keys ; key++)
  812.   {
  813.     if ((((ulonglong) 1 << key) & info->s->state.key_map) &&
  814. info->s->keyinfo[key].flag & HA_NOSAME)
  815.     {
  816.       VOID(_mi_make_key(info,key,tmp_key,record,0L));
  817.       return mi_rkey(info,file_info->record,(int) key,(char*) tmp_key,0,
  818.      HA_READ_KEY_EXACT);
  819.     }
  820.   }
  821.   return 1;
  822. }
  825. static void printf_log(const char *format,...)
  826. {
  827.   char llbuff[21];
  828.   va_list args;
  829.   va_start(args,format);
  830.   if (verbose > 2)
  831.     printf("%9s:",llstr(isamlog_filepos,llbuff));
  832.   if (verbose > 1)
  833.     printf("%5ld ",isamlog_process); /* Write process number */
  834.   (void) vprintf((char*) format,args);
  835.   putchar('n');
  836.   va_end(args);
  837. }
  840. static bool cmp_filename(struct file_info *file_info, my_string name)
  841. {
  842.   if (!file_info)
  843.     return 1;
  844.   return strcmp(file_info->name,name) ? 1 : 0;
  845. }