← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_file.cc

  • Committer: Brian Aker
  • Date: 2009-05-23 16:15:00 UTC
  • mto: This revision was merged to the branch mainline in revision 1038.
  • Revision ID: brian@gaz-20090523161500-nldnoav8b7x1iz1b
Remove locks around my_open(). Open file counts are now "best effort" (not
that they were ever exact, since Innodb didn't use the calls).

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_file.cc
1
 
/* Copyright (C) 2000 MySQL AB
2
 
 
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; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
#include "mysys/mysys_priv.h"
17
 
#include "my_static.h"
18
 
#include <mystrings/m_string.h>
19
 
#include <stdlib.h>
20
 
#include <string.h>
21
 
 
22
 
/*
23
 
  set how many open files we want to be able to handle
24
 
 
25
 
  SYNOPSIS
26
 
    set_maximum_open_files()
27
 
    max_file_limit              Files to open
28
 
 
29
 
  NOTES
30
 
    The request may not fulfilled becasue of system limitations
31
 
 
32
 
  RETURN
33
 
    Files available to open.
34
 
    May be more or less than max_file_limit!
35
 
*/
36
 
 
37
 
#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
38
 
 
39
 
#ifndef RLIM_INFINITY
40
 
#define RLIM_INFINITY ((rlim_t) 0xffffffff)
41
 
#endif
42
 
 
43
 
static uint64_t set_max_open_files(uint64_t max_file_limit)
44
 
{
45
 
  struct rlimit rlim;
46
 
  rlim_t old_cur;
47
 
 
48
 
  if (!getrlimit(RLIMIT_NOFILE,&rlim))
49
 
  {
50
 
    old_cur= rlim.rlim_cur;
51
 
    if (rlim.rlim_cur == (rlim_t)RLIM_INFINITY)
52
 
      rlim.rlim_cur = max_file_limit;
53
 
    if (rlim.rlim_cur >= max_file_limit)
54
 
    {
55
 
      return rlim.rlim_cur;
56
 
    }
57
 
    rlim.rlim_cur= rlim.rlim_max= max_file_limit;
58
 
    if (setrlimit(RLIMIT_NOFILE, &rlim))
59
 
      max_file_limit= (old_cur < UINT32_MAX) ? (uint32_t)old_cur : UINT32_MAX;
60
 
    else
61
 
    {
62
 
      rlim.rlim_cur= 0;                 /* Safety if next call fails */
63
 
      (void) getrlimit(RLIMIT_NOFILE,&rlim);
64
 
      if (rlim.rlim_cur)                        /* If call didn't fail */
65
 
        max_file_limit= (uint32_t) rlim.rlim_cur;
66
 
    }
67
 
  }
68
 
  return(max_file_limit);
69
 
}
70
 
 
71
 
#else
72
 
static int set_max_open_files(uint64_t max_file_limit)
73
 
{
74
 
  /* We don't know the limit. Return best guess */
75
 
  return cmin(max_file_limit, OS_FILE_LIMIT);
76
 
}
77
 
#endif
78
 
 
79
 
 
80
 
/*
81
 
  Change number of open files
82
 
 
83
 
  SYNOPSIS:
84
 
    my_set_max_open_files()
85
 
    files               Number of requested files
86
 
 
87
 
  RETURN
88
 
    number of files available for open
89
 
*/
90
 
 
91
 
uint64_t my_set_max_open_files(uint64_t files)
92
 
{
93
 
  struct st_my_file_info *tmp;
94
 
 
95
 
  files= set_max_open_files(cmin(files, OS_FILE_LIMIT));
96
 
  if (files <= MY_NFILE)
97
 
    return(files);
98
 
 
99
 
  if (!(tmp= (st_my_file_info*) malloc((size_t)cmax(sizeof(st_my_file_info) * files,SIZE_MAX))))
100
 
    return(MY_NFILE);
101
 
 
102
 
  /* Copy any initialized files */
103
 
  memcpy(tmp, my_file_info,
104
 
         sizeof(*tmp) *
105
 
            (size_t)cmin(my_file_limit,
106
 
                 cmax(files,UINT32_MAX)));
107
 
  /*
108
 
    The int cast is necessary since 'my_file_limits' might be greater
109
 
    than 'files'.
110
 
  */
111
 
  memset(tmp + my_file_limit, 0,
112
 
         cmax((int) (files - my_file_limit), 0)*sizeof(*tmp));
113
 
  my_free_open_file_info();                     /* Free if already allocated */
114
 
  my_file_info= tmp;
115
 
  my_file_limit= (size_t)cmax(UINT32_MAX,files);
116
 
  return(files);
117
 
}
118
 
 
119
 
 
120
 
void my_free_open_file_info()
121
 
{
122
 
  if (my_file_info != my_file_info_default)
123
 
  {
124
 
    /* Copy data back for my_print_open_files */
125
 
    memcpy(my_file_info_default, my_file_info,
126
 
           sizeof(*my_file_info_default)* MY_NFILE);
127
 
    free((char*) my_file_info);
128
 
    my_file_info= my_file_info_default;
129
 
    my_file_limit= MY_NFILE;
130
 
  }
131
 
  return;
132
 
}