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

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

MySQL数据库

开发平台：

Visual C++

isamlog.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 "isamdef.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 isamlog_file_info {
  33.   long process;
  34.   int  filenr,id;
  35.   my_string name,show_name,record;
  36.   N_INFO *isam;
  37.   bool closed,used;
  38.   ulong accessed;
  39. };
  41. struct test_if_open_param {
  42.   my_string name;
  43.   int max_id;
  44. };
  46. struct st_access_param
  47. {
  48.   ulong min_accessed;
  49.   struct isamlog_file_info *found;
  50. };
  52. #define NO_FILEPOS (ulong) ~0L
  54. extern int main(int argc,char * *argv);
  55. static void get_options(int *argc,char ***argv);
  56. static int examine_log(my_string file_name,char **table_names);
  57. static int read_string(IO_CACHE *file,gptr *to,uint length);
  58. static int file_info_compare(void *a,void *b);
  59. static int test_if_open(struct isamlog_file_info *key,element_count count,
  60. struct test_if_open_param *param);
  61. static void fix_blob_pointers(N_INFO *isam,byte *record);
  62. static uint set_maximum_open_files(uint);
  63. static int test_when_accessed(struct isamlog_file_info *key,element_count count,
  64.       struct st_access_param *access_param);
  65. static void file_info_free(struct isamlog_file_info *info);
  66. static int close_some_file(TREE *tree);
  67. static int reopen_closed_file(TREE *tree,struct isamlog_file_info *file_info);
  68. static int find_record_with_key(struct isamlog_file_info *file_info,
  69. byte *record);
  70. static void printf_log(const char *str,...);
  71. static bool cmp_filename(struct isamlog_file_info *file_info,my_string name);
  73. static uint verbose=0,update=0,test_info=0,max_files=0,re_open_count=0,
  74.   recover=0,prefix_remove=0,opt_processes=0;
  75. static my_string log_filename=0,filepath=0,write_filename=0,record_pos_file=0;
  76. static ulong com_count[10][3],number_of_commands=(ulong) ~0L,start_offset=0,
  77.      record_pos= NO_FILEPOS,isamlog_filepos,isamlog_process;
  78. static const char *command_name[]=
  79. {"open","write","update","delete","close","extra","lock","re-open",NullS};
  82. int main(int argc, char **argv)
  83. {
  84.   int error,i,first;
  85.   ulong total_count,total_error,total_recover;
  86.   MY_INIT(argv[0]);
  88.   log_filename=nisam_log_filename;
  89.   get_options(&argc,&argv);
  90.  /* Nr of isam-files */
  91.   max_files=(set_maximum_open_files(min(max_files,8))-6)/2;
  93.   if (update)
  94.     printf("Trying to %s ISAM 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(nisam_panic(HA_PANIC_CLOSE));
  124.   my_end(test_info ? MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
  125.   exit(error);
  126.   return 0; /* No compiler warning */
  127. } /* main */
  130. static void get_options(register int *argc, register char ***argv)
  131. {
  132.   int help,version;
  133.   const char *pos,*usage;
  134.   char option;
  136.   help=0;
  137.   usage="Usage: %s [-?iruvIPV] [-c #] [-f #] [-F filepath/] [-o #] [-R file recordpos] [-w write_file] [log-filename [table ...]] n";
  138.   pos= "";
  140.   while (--*argc > 0 && *(pos = *(++*argv)) == '-' ) {
  141.     while (*++pos)
  142.     {
  143.       version=0;
  144.       switch((option=*pos)) {
  145.       case '#':
  146. DBUG_PUSH (++pos);
  147. pos=" "; /* Skip rest of arg */
  148. break;
  149.       case 'c':
  150. if (! *++pos)
  151. {
  152.   if (!--*argc)
  153.     goto err;
  154.   else
  155.     pos= *(++*argv);
  156. }
  157. number_of_commands=(ulong) atol(pos);
  158. pos=" ";
  159. break;
  160.       case 'u':
  161. update=1;
  162. break;
  163.       case 'f':
  164. if (! *++pos)
  165. {
  166.   if (!--*argc)
  167.     goto err;
  168.   else
  169.     pos= *(++*argv);
  170. }
  171. max_files=(uint) atoi(pos);
  172. pos=" ";
  173. break;
  174.       case 'i':
  175. test_info=1;
  176. break;
  177.       case 'o':
  178. if (! *++pos)
  179. {
  180.   if (!--*argc)
  181.     goto err;
  182.   else
  183.     pos= *(++*argv);
  184. }
  185. start_offset=(ulong) atol(pos);
  186. pos=" ";
  187. break;
  188.       case 'p':
  189. if (! *++pos)
  190. {
  191.   if (!--*argc)
  192.     goto err;
  193.   else
  194.     pos= *(++*argv);
  195. }
  196. prefix_remove=atoi(pos);
  197. break;
  198.       case 'r':
  199. update=1;
  200. recover++;
  201. break;
  202.       case 'P':
  203. opt_processes=1;
  204. break;
  205.       case 'R':
  206. if (! *++pos)
  207. {
  208.   if (!--*argc)
  209.     goto err;
  210.   else
  211.     pos= *(++*argv);
  212. }
  213. record_pos_file=(char*) pos;
  214. if (!--*argc)
  215.   goto err;
  216. record_pos=(ulong) atol(*(++*argv));
  217. pos= " ";
  218. break;
  219.       case 'v':
  220. verbose++;
  221. break;
  222.       case 'w':
  223. if (! *++pos)
  224. {
  225.   if (!--*argc)
  226.     goto err;
  227.   else
  228.     pos= *(++*argv);
  229. }
  230. write_filename=(char*) pos;
  231. pos=" ";
  232. break;
  233.       case 'F':
  234. if (! *++pos)
  235. {
  236.   if (!--*argc)
  237.     goto err;
  238.   else
  239.     pos= *(++*argv);
  240. }
  241. filepath= (char*) pos;
  242. pos=" ";
  243. break;
  244.       case 'V':
  245. version=1;
  246. /* Fall through */
  247.       case 'I':
  248.       case '?':
  249. printf("%s  Ver 3.3 for %s at %sn",my_progname,SYSTEM_TYPE,
  250.        MACHINE_TYPE);
  251. puts("By Monty, for your professional usen");
  252. if (version)
  253.   break;
  254. puts("Write info about whats in a ISAM log file.");
  255. printf("If no file name is given %s is usedn",log_filename);
  256. puts("");
  257. printf(usage,my_progname);
  258. puts("");
  259. puts("Options: -? or -I "Info"     -V "version"   -c "do only # commands"");
  260. puts("         -f "max open files" -F "filepath"  -i "extra info"");
  261. puts("         -o "offset"         -p # "remove # components from path"");
  262. puts("         -r "recover"        -R "file recordposition"");
  263. puts("         -u "update"         -v "verbose"   -w "write file"");
  264. puts("         -P "processes"");
  265. puts("nOne can give a second and a third '-v' for more verbose.");
  266. puts("Normaly one does a update (-u).");
  267. puts("If a recover is done all writes and all possibly updates and deletes is donenand errors are only counted.");
  268. puts("If one gives table names as arguments only these tables will be updatedn");
  269. help=1;
  270. break;
  271.       default:
  272. printf("illegal option: "-%c"n",*pos);
  273. break;
  274.       }
  275.     }
  276.   }
  277.   if (! *argc)
  278.   {
  279.     if (help)
  280.     exit(0);
  281.     (*argv)++;
  282.   }
  283.   if (*argc >= 1)
  284.   {
  285.     log_filename=(char*) pos;
  286.     (*argc)--;
  287.     (*argv)++;
  288.   }
  289.   return;
  290.  err:
  291.   VOID(fprintf(stderr,"option "%c" used without or with wrong argumentn",
  292.        option));
  293.   exit(1);
  294. }
  297. static int examine_log(my_string file_name, char **table_names)
  298. {
  299.   uint command,result,files_open;
  300.   ulong access_time,length;
  301.   uint32 filepos;
  302.   int lock_command,ni_result;
  303.   char isam_file_name[FN_REFLEN];
  304.   uchar head[20];
  305.   gptr buff;
  306.   struct test_if_open_param open_param;
  307.   IO_CACHE cache;
  308.   File file;
  309.   FILE *write_file;
  310.   enum ha_extra_function extra_command;
  311.   TREE tree;
  312.   struct isamlog_file_info file_info,*curr_file_info;
  313.   char llbuff[22],llbuff2[22];
  314.   DBUG_ENTER("examine_log");
  316.   if ((file=my_open(file_name,O_RDONLY,MYF(MY_WME))) < 0)
  317.     DBUG_RETURN(1);
  318.   write_file=0;
  319.   if (write_filename)
  320.   {
  321.     if (!(write_file=my_fopen(write_filename,O_WRONLY,MYF(MY_WME))))
  322.     {
  323.       my_close(file,MYF(0));
  324.       DBUG_RETURN(1);
  325.     }
  326.   }
  328.   init_io_cache(&cache,file,0,READ_CACHE,start_offset,0,MYF(0));
  329.   bzero((gptr) com_count,sizeof(com_count));
  330.   init_tree(&tree,0,0,sizeof(file_info),(qsort_cmp2) file_info_compare,1,
  331.     (tree_element_free) file_info_free, NULL);
  332.   VOID(init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,KEY_CACHE_SIZE,
  333.                       0,0));
  334.   files_open=0; access_time=0;
  335.   while (access_time++ != number_of_commands &&
  336.  !my_b_read(&cache,(byte*) head,9))
  337.   {
  338.     isamlog_filepos=my_b_tell(&cache)-9L;
  339.     file_info.filenr=uint2korr(head+1);
  340.     isamlog_process=file_info.process=(long) uint4korr(head+3);
  341.     if (!opt_processes)
  342.       file_info.process=0;
  343.     result=uint2korr(head+7);
  344.     if ((curr_file_info=(struct isamlog_file_info*)
  345.  tree_search(&tree, &file_info, tree.custom_arg)))
  346.     {
  347.       curr_file_info->accessed=access_time;
  348.       if (update && curr_file_info->used && curr_file_info->closed)
  349.       {
  350. if (reopen_closed_file(&tree,curr_file_info))
  351. {
  352.   command=sizeof(com_count)/sizeof(com_count[0][0])/3;
  353.   result=0;
  354.   goto com_err;
  355. }
  356.       }
  357.     }
  358.     command=(uint) head[0];
  359.     if (command < sizeof(com_count)/sizeof(com_count[0][0])/3 &&
  360. (!table_names[0] || (curr_file_info && curr_file_info->used)))
  361.     {
  362.       com_count[command][0]++;
  363.       if (result)
  364. com_count[command][1]++;
  365.     }
  366.     switch ((enum nisam_log_commands) command) {
  367.     case LOG_OPEN:
  368.       if (!table_names[0])
  369.       {
  370. com_count[command][0]--; /* Must be counted explicite */
  371. if (result)
  372.   com_count[command][1]--;
  373.       }
  375.       if (curr_file_info)
  376. printf("nWarning: %s is opened with same process and filenumbernMaybe you should use the -P option ?n",
  377.        curr_file_info->show_name);
  378.       if (my_b_read(&cache,(byte*) head,2))
  379. goto err;
  380.       file_info.name=0;
  381.       file_info.show_name=0;
  382.       file_info.record=0;
  383.       if (read_string(&cache,(gptr*) &file_info.name,(uint) uint2korr(head)))
  384. goto err;
  385.       {
  386. uint i;
  387. char *pos,*to;
  389. /* Fix if old DOS files to new format */
  390. for (pos=file_info.name; (pos=strchr(pos,'\')) ; pos++)
  391.   *pos= '/';
  393. pos=file_info.name;
  394. for (i=0 ; i < prefix_remove ; i++)
  395. {
  396.   char *next;
  397.   if (!(next=strchr(pos,'/')))
  398.     break;
  399.   pos=next+1;
  400. }
  401. to=isam_file_name;
  402. if (filepath)
  403.   to=convert_dirname(isam_file_name, filepath, NullS);
  404. strmov(to,pos);
  405. fn_ext(isam_file_name)[0]=0; /* Remove extension */
  406.       }
  407.       open_param.name=file_info.name;
  408.       open_param.max_id=0;
  409.       VOID(tree_walk(&tree,(tree_walk_action) test_if_open,(void*) &open_param,
  410.      left_root_right));
  411.       file_info.id=open_param.max_id+1;
  412.       file_info.show_name=my_memdup(isam_file_name,
  413.     (uint) strlen(isam_file_name)+6,
  414.     MYF(MY_WME));
  415.       if (file_info.id > 1)
  416. sprintf(strend(file_info.show_name),"<%d>",file_info.id);
  417.       file_info.closed=1;
  418.       file_info.accessed=access_time;
  419.       file_info.used=1;
  420.       if (table_names[0])
  421.       {
  422. char **name;
  423. file_info.used=0;
  424. for (name=table_names ; *name ; name++)
  425. {
  426.   if (!strcmp(*name,isam_file_name))
  427.     file_info.used=1; /* Update/log only this */
  428. }
  429.       }
  430.       if (update && file_info.used)
  431.       {
  432. if (files_open >= max_files)
  433. {
  434.   if (close_some_file(&tree))
  435.     goto com_err;
  436.   files_open--;
  437. }
  438. if (!(file_info.isam= nisam_open(isam_file_name,O_RDWR,
  439.  HA_OPEN_WAIT_IF_LOCKED)))
  440.   goto com_err;
  441. if (!(file_info.record=my_malloc(file_info.isam->s->base.reclength,
  442.  MYF(MY_WME))))
  443.   goto end;
  444. files_open++;
  445. file_info.closed=0;
  446.       }
  447.       VOID(tree_insert(&tree, (gptr) &file_info, 0, tree.custom_arg));
  448.       if (file_info.used)
  449.       {
  450. if (verbose && !record_pos_file)
  451.   printf_log("%s: open -> %d",file_info.show_name, file_info.filenr);
  452. com_count[command][0]++;
  453. if (result)
  454.   com_count[command][1]++;
  455.       }
  456.       break;
  457.     case LOG_CLOSE:
  458.       if (verbose && !record_pos_file &&
  459.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  460. printf_log("%s: %s -> %d",FILENAME(curr_file_info),
  461.        command_name[command],result);
  462.       if (curr_file_info)
  463.       {
  464. if (!curr_file_info->closed)
  465.   files_open--;
  466. VOID(tree_delete(&tree, (gptr) curr_file_info, tree.custom_arg));
  467.       }
  468.       break;
  469.     case LOG_EXTRA:
  470.       if (my_b_read(&cache,(byte*) head,sizeof(extra_command)))
  471. goto err;
  472.       memcpy_fixed(&extra_command,head,sizeof(extra_command));
  473.       if (verbose && !record_pos_file &&
  474.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  475. printf_log("%s: %s(%d) -> %d",FILENAME(curr_file_info),
  476.    command_name[command], (int) extra_command,result);
  477.       if (update && curr_file_info && !curr_file_info->closed)
  478.       {
  479. if (nisam_extra(curr_file_info->isam,extra_command) != (int) result)
  480. {
  481.   fflush(stdout);
  482.   VOID(fprintf(stderr,
  483.        "Warning: error %d, expected %d on command %s at %sn",
  484.        my_errno,result,command_name[command],
  485.        llstr(isamlog_filepos,llbuff)));
  486.   fflush(stderr);
  487. }
  488.       }
  489.       break;
  490.     case LOG_DELETE:
  491.       if (my_b_read(&cache,(byte*) head,sizeof(filepos)))
  492. goto err;
  493.       memcpy_fixed(&filepos,head,sizeof(filepos));
  494.       if (verbose && (!record_pos_file ||
  495.       ((record_pos == filepos || record_pos == NO_FILEPOS) &&
  496.        !cmp_filename(curr_file_info,record_pos_file))) &&
  497.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  498. printf_log("%s: %s at %ld -> %d",FILENAME(curr_file_info),
  499.    command_name[command],(long) filepos,result);
  500.       if (update && curr_file_info && !curr_file_info->closed)
  501.       {
  502. if (nisam_rrnd(curr_file_info->isam,curr_file_info->record,filepos))
  503. {
  504.   if (!recover)
  505.     goto com_err;
  506.   com_count[command][2]++; /* Mark error */
  507. }
  508. ni_result=nisam_delete(curr_file_info->isam,curr_file_info->record);
  509. if ((ni_result == 0 && result) ||
  510.     (ni_result && (uint) my_errno != result))
  511. {
  512.   if (!recover)
  513.     goto com_err;
  514.   if (ni_result)
  515.     com_count[command][2]++; /* Mark error */
  516.   if (verbose)
  517.     printf_log("error: Got result %d from mi_delete instead of %d",
  518.        ni_result, result);
  519. }
  520.       }
  521.       break;
  522.     case LOG_WRITE:
  523.     case LOG_UPDATE:
  524.       if (my_b_read(&cache,(byte*) head,8))
  525. goto err;
  526.       filepos=uint4korr(head);
  527.       length=uint4korr(head+4);
  528.       buff=0;
  529.       if (read_string(&cache,&buff,(uint) length))
  530. goto err;
  531.       if ((!record_pos_file ||
  532.   ((record_pos == filepos || record_pos == NO_FILEPOS) &&
  533.    !cmp_filename(curr_file_info,record_pos_file))) &&
  534.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  535.       {
  536. if (write_file &&
  537.     (my_fwrite(write_file,buff,length,MYF(MY_WAIT_IF_FULL | MY_NABP))))
  538.   goto end;
  539. if (verbose)
  540.   printf_log("%s: %s at %ld, length=%ld -> %d",
  541.      FILENAME(curr_file_info),
  542.      command_name[command], filepos,length,result);
  543.       }
  544.       if (update && curr_file_info && !curr_file_info->closed)
  545.       {
  546. if (curr_file_info->isam->s->base.blobs)
  547.   fix_blob_pointers(curr_file_info->isam,buff);
  548. if ((enum nisam_log_commands) command == LOG_UPDATE)
  549. {
  550.   if (nisam_rrnd(curr_file_info->isam,curr_file_info->record,filepos))
  551.   {
  552.     if (!recover)
  553.     {
  554.       result=0;
  555.       goto com_err;
  556.     }
  557.     if (verbose)
  558.       printf_log("error: Didn't find row to update with mi_rrnd");
  559.     if (recover == 1 || result ||
  560. find_record_with_key(curr_file_info,buff))
  561.     {
  562.       com_count[command][2]++; /* Mark error */
  563.       break;
  564.     }
  565.   }
  566.   ni_result=nisam_update(curr_file_info->isam,curr_file_info->record,
  567.       buff);
  568.   if ((ni_result == 0 && result) ||
  569.       (ni_result && (uint) my_errno != result))
  570.   {
  571.     if (!recover)
  572.       goto com_err;
  573.     if (verbose)
  574.       printf_log("error: Got result %d from mi_update instead of %d",
  575.  ni_result, result);
  576.     if (ni_result)
  577.       com_count[command][2]++; /* Mark error */
  578.   }
  579. }
  580. else
  581. {
  582.   ni_result=nisam_write(curr_file_info->isam,buff);
  583.   if ((ni_result == 0 && result) ||
  584.       (ni_result && (uint) my_errno != result))
  585.   {
  586.     if (!recover)
  587.       goto com_err;
  588.     if (ni_result)
  589.       com_count[command][2]++; /* Mark error */
  590.   }
  591.   if (! recover && filepos != curr_file_info->isam->lastpos)
  592.   {
  593.     printf("error: Wrote at position: %s, should have been %s",
  594.    llstr(curr_file_info->isam->lastpos,llbuff),
  595.    llstr(filepos,llbuff2));
  596.     goto end;
  597.   }
  598. }
  599.       }
  600.       my_free(buff,MYF(0));
  601.       break;
  602.     case LOG_LOCK:
  603.       if (my_b_read(&cache,(byte*) head,sizeof(lock_command)))
  604. goto err;
  605.       memcpy_fixed(&lock_command,head,sizeof(lock_command));
  606.       if (verbose && !record_pos_file &&
  607.   (!table_names[0] || (curr_file_info && curr_file_info->used)))
  608. printf_log("%s: %s(%d) -> %dn",FILENAME(curr_file_info),
  609.    command_name[command],lock_command,result);
  610.       if (update && curr_file_info && !curr_file_info->closed)
  611.       {
  612. if (nisam_lock_database(curr_file_info->isam,lock_command) !=
  613.     (int) result)
  614.   goto com_err;
  615.       }
  616.       break;
  617.     default:
  618.       VOID(fprintf(stderr,
  619.    "Error: found unknown command %d in logfile, abortedn",
  620.    command));
  621.       fflush(stderr);
  622.       goto end;
  623.     }
  624.   }
  625.   end_key_cache(dflt_key_cache,1);
  626.   delete_tree(&tree);
  627.   VOID(end_io_cache(&cache));
  628.   VOID(my_close(file,MYF(0)));
  629.   if (write_file && my_fclose(write_file,MYF(MY_WME)))
  630.     DBUG_RETURN(1);
  631.   DBUG_RETURN(0);
  633.  err:
  634.   fflush(stdout);
  635.   VOID(fprintf(stderr,"Got error %d when reading from logfilen",my_errno));
  636.   fflush(stderr);
  637.   goto end;
  638.  com_err:
  639.   fflush(stdout);
  640.   VOID(fprintf(stderr,"Got error %d, expected %d on command %s at %sn",
  641.        my_errno,result,command_name[command],
  642.        llstr(isamlog_filepos,llbuff)));
  643.   fflush(stderr);
  644.  end:
  645.   end_key_cache(dflt_key_cache,1);
  646.   delete_tree(&tree);
  647.   VOID(end_io_cache(&cache));
  648.   VOID(my_close(file,MYF(0)));
  649.   if (write_file)
  650.     VOID(my_fclose(write_file,MYF(MY_WME)));
  651.   DBUG_RETURN(1);
  652. }
  655. static int read_string(IO_CACHE *file, reg1 gptr *to, reg2 uint length)
  656. {
  657.   DBUG_ENTER("read_string");
  659.   if (*to)
  660.     my_free((gptr) *to,MYF(0));
  661.   if (!(*to= (gptr) my_malloc(length+1,MYF(MY_WME))) ||
  662.       my_b_read(file,(byte*) *to,length))
  663.   {
  664.     if (*to)
  665.       my_free(*to,MYF(0));
  666.     *to= 0;
  667.     DBUG_RETURN(1);
  668.   }
  669.   *((char*) *to+length)= '';
  670.   DBUG_RETURN (0);
  671. } /* read_string */
  674. static int file_info_compare(void *a, void *b)
  675. {
  676.   long lint;
  678.   if ((lint=((struct isamlog_file_info*) a)->process -
  679.        ((struct isamlog_file_info*) b)->process))
  680.     return lint < 0L ? -1 : 1;
  681.   return (((struct isamlog_file_info*) a)->filenr -
  682.   ((struct isamlog_file_info*) b)->filenr);
  683. }
  685. /* ARGSUSED */
  687. static int test_if_open (struct isamlog_file_info *key,
  688.  element_count count __attribute__((unused)),
  689.  struct test_if_open_param *param)
  690. {
  691.   if (!strcmp(key->name,param->name) && key->id > param->max_id)
  692.     param->max_id=key->id;
  693.   return 0;
  694. }
  697. static void fix_blob_pointers( N_INFO *info, byte *record)
  698. {
  699.   byte *pos;
  700.   N_BLOB *blob,*end;
  702.   pos=record+info->s->base.reclength;
  703.   for (end=info->blobs+info->s->base.blobs, blob= info->blobs;
  704.        blob != end ;
  705.        blob++)
  706.   {
  707.     bmove(record+blob->offset+blob->pack_length,&pos,sizeof(char*));
  708.     pos+=_calc_blob_length(blob->pack_length,record+blob->offset);
  709.   }
  710. }
  712. static uint set_maximum_open_files(uint maximum_files)
  713. {
  714. #if defined(HAVE_GETRUSAGE) && defined(RLIMIT_NOFILE)
  715.   struct rlimit rlimit;
  716.   int old_max;
  718.   if (maximum_files > MY_NFILE)
  719.     maximum_files=MY_NFILE; /* Don't crash my_open */
  721.   if (!getrlimit(RLIMIT_NOFILE,&rlimit))
  722.   {
  723.     old_max=rlimit.rlim_max;
  724.     if (maximum_files && (int) maximum_files > old_max)
  725.       rlimit.rlim_max=maximum_files;
  726.     rlimit.rlim_cur=rlimit.rlim_max;
  727.     if (setrlimit(RLIMIT_NOFILE,&rlimit))
  728.     {
  729.       if (old_max != (int) maximum_files)
  730.       { /* Set as much as we can */
  731. rlimit.rlim_max=rlimit.rlim_cur=old_max;
  732. setrlimit(RLIMIT_NOFILE,&rlimit);
  733.       }
  734.     }
  735.     getrlimit(RLIMIT_NOFILE,&rlimit); /* Read if broken setrlimit */
  736.     if (maximum_files && maximum_files < rlimit.rlim_cur)
  737.       VOID(fprintf(stderr,"Warning: Error from setrlimit: Max open files is %dn",old_max));
  738.     return rlimit.rlim_cur;
  739.   }
  740. #endif
  741.   return min(maximum_files,MY_NFILE);
  742. }
  744. /* close the file with hasn't been accessed for the longest time */
  745. /* ARGSUSED */
  747. static int test_when_accessed (struct isamlog_file_info *key,
  748.        element_count count __attribute__((unused)),
  749.        struct st_access_param *access_param)
  750. {
  751.   if (key->accessed < access_param->min_accessed && ! key->closed)
  752.   {
  753.     access_param->min_accessed=key->accessed;
  754.     access_param->found=key;
  755.   }
  756.   return 0;
  757. }
  760. static void file_info_free(struct isamlog_file_info *fileinfo)
  761. {
  762.   DBUG_ENTER("file_info_free");
  763.   if (update)
  764.   {
  765.     if (!fileinfo->closed)
  766.       VOID(nisam_close(fileinfo->isam));
  767.     if (fileinfo->record)
  768.       my_free(fileinfo->record,MYF(0));
  769.   }
  770.   my_free(fileinfo->name,MYF(0));
  771.   my_free(fileinfo->show_name,MYF(0));
  772.   DBUG_VOID_RETURN;
  773. }
  777. static int close_some_file(TREE *tree)
  778. {
  779.   struct st_access_param access_param;
  781.   access_param.min_accessed=LONG_MAX;
  782.   access_param.found=0;
  784.   VOID(tree_walk(tree,(tree_walk_action) test_when_accessed,
  785.  (void*) &access_param,left_root_right));
  786.   if (!access_param.found)
  787.     return 1; /* No open file that is possibly to close */
  788.   if (nisam_close(access_param.found->isam))
  789.     return 1;
  790.   access_param.found->closed=1;
  791.   return 0;
  792. }
  795. static int reopen_closed_file(TREE *tree, struct isamlog_file_info *fileinfo)
  796. {
  797.   char name[FN_REFLEN];
  798.   if (close_some_file(tree))
  799.     return 1; /* No file to close */
  800.   strmov(name,fileinfo->show_name);
  801.   if (fileinfo->id > 1)
  802.     *strrchr(name,'<')=''; /* Remove "<id>" */
  804.   if (!(fileinfo->isam= nisam_open(name,O_RDWR,HA_OPEN_WAIT_IF_LOCKED)))
  805.     return 1;
  806.   fileinfo->closed=0;
  807.   re_open_count++;
  808.   return 0;
  809. }
  811. /* Try to find record with uniq key */
  813. static int find_record_with_key(struct isamlog_file_info *file_info,
  814. byte *record)
  815. {
  816.   uint key;
  817.   N_INFO *info=file_info->isam;
  818.   uchar tmp_key[N_MAX_KEY_BUFF];
  820.   for (key=0 ; key < info->s->state.keys ; key++)
  821.   {
  822.     if (info->s->keyinfo[key].base.flag & HA_NOSAME)
  823.     {
  824.       VOID(_nisam_make_key(info,key,tmp_key,record,0L));
  825.       return nisam_rkey(info,file_info->record,(int) key,(char*) tmp_key,0,
  826.      HA_READ_KEY_EXACT);
  827.     }
  828.   }
  829.   return 1;
  830. }
  833. static void printf_log(const char *format,...)
  834. {
  835.   char llbuff[21];
  836.   va_list args;
  837.   va_start(args,format);
  838.   if (verbose > 2)
  839.     printf("%9s:",llstr(isamlog_filepos,llbuff));
  840.   if (verbose > 1)
  841.     printf("%5ld ",isamlog_process); /* Write process number */
  842.   (void) vprintf((char*) format,args);
  843.   putchar('n');
  844.   va_end(args);
  845. }
  848. static bool cmp_filename(struct isamlog_file_info *file_info,my_string name)
  849. {
  850.   if (!file_info)
  851.     return 1;
  852.   return strcmp(file_info->name,name) ? 1 : 0;
  853. }