MySQL数据库

开发平台：
Visual C++

my_file.c：源码内容
							/* Copyright (C) 2000 MySQL AB
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
#include "mysys_priv.h"
#include "my_static.h"
#include <m_string.h>
/*
  set how many open files we want to be able to handle
  SYNOPSIS
    set_maximum_open_files()
    max_file_limit		Files to open
  NOTES
    The request may not fulfilled becasue of system limitations
  RETURN
    Files available to open.
    May be more or less than max_file_limit!
*/
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE) && !defined(HAVE_mit_thread)
#ifndef RLIM_INFINITY
#define RLIM_INFINITY ((uint) 0xffffffff)
#endif
static uint set_max_open_files(uint max_file_limit)
{
  struct rlimit rlimit;
  uint old_cur;
  DBUG_ENTER("set_max_open_files");
  DBUG_PRINT("enter",("files: %u", max_file_limit));
  if (!getrlimit(RLIMIT_NOFILE,&rlimit))
  {
    old_cur= (uint) rlimit.rlim_cur;
    DBUG_PRINT("info", ("rlim_cur: %u  rlim_max: %u",
			(uint) rlimit.rlim_cur,
			(uint) rlimit.rlim_max));
    if (rlimit.rlim_cur == RLIM_INFINITY)
      rlimit.rlim_cur = max_file_limit;
    if (rlimit.rlim_cur >= max_file_limit)
      DBUG_RETURN(rlimit.rlim_cur);		/* purecov: inspected */
    rlimit.rlim_cur= rlimit.rlim_max= max_file_limit;
    if (setrlimit(RLIMIT_NOFILE, &rlimit))
      max_file_limit= old_cur;			/* Use original value */
    else
    {
      rlimit.rlim_cur= 0;			/* Safety if next call fails */
      (void) getrlimit(RLIMIT_NOFILE,&rlimit);
      DBUG_PRINT("info", ("rlim_cur: %u", (uint) rlimit.rlim_cur));
      if (rlimit.rlim_cur)			/* If call didn't fail */
	max_file_limit= (uint) rlimit.rlim_cur;
    }
  }
  DBUG_PRINT("exit",("max_file_limit: %u", max_file_limit));
  DBUG_RETURN(max_file_limit);
}
#elif defined (OS2)
static uint set_max_open_files(uint max_file_limit)
{
  LONG     cbReqCount;
  ULONG    cbCurMaxFH0;
  APIRET   ulrc;
  DBUG_ENTER("set_max_open_files");
  /* get current limit */
  cbReqCount = 0;
  DosSetRelMaxFH( &cbReqCount, &cbCurMaxFH0);
  /* set new limit */
  if ((cbReqCount = max_file_limit - cbCurMaxFH0) > 0)
    ulrc = DosSetRelMaxFH( &cbReqCount, &cbCurMaxFH);
  DBUG_RETURN(cbCurMaxFH0);
}
#else
static int set_max_open_files(uint max_file_limit)
{
  /* We don't know the limit. Return best guess */
  return min(max_file_limit, OS_FILE_LIMIT);
}
#endif
/*
  Change number of open files
  SYNOPSIS:
    my_set_max_open_files()
    files		Number of requested files
  RETURN
    number of files available for open
*/
uint my_set_max_open_files(uint files)
{
  struct st_my_file_info *tmp;
  DBUG_ENTER("my_set_max_open_files");
  DBUG_PRINT("enter",("files: %u  my_file_limit: %u", files, my_file_limit));
  files= set_max_open_files(min(files, OS_FILE_LIMIT));
  if (files <= MY_NFILE)
    DBUG_RETURN(files);
  if (!(tmp= (struct st_my_file_info*) my_malloc(sizeof(*tmp) * files,
						 MYF(MY_WME))))
    DBUG_RETURN(MY_NFILE);
  /* Copy any initialized files */
  memcpy((char*) tmp, (char*) my_file_info, sizeof(*tmp) * my_file_limit);
  my_free_open_file_info();			/* Free if already allocated */
  my_file_info= tmp;
  my_file_limit= files;
  DBUG_PRINT("exit",("files: %u", files));
  DBUG_RETURN(files);
}
void my_free_open_file_info()
{
  DBUG_ENTER("my_free_file_info");
  if (my_file_info != my_file_info_default)
  {
    my_free((char*) my_file_info, MYF(0));
    my_file_info= my_file_info_default;
  }
  DBUG_VOID_RETURN;
}

						