Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
file-impl.cpp
Go to the documentation of this file.
1 /* -*- c-basic-offset: 2 -*- */
2 /* Copyright(C) 2011 Brazil
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Lesser General Public
6  License version 2.1 as published by the Free Software Foundation.
7 
8  This library 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 GNU
11  Lesser General Public License for more details.
12 
13  You should have received a copy of the GNU Lesser General Public
14  License along with this library; if not, write to the Free Software
15  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16 */
17 
18 #include "file-impl.hpp"
19 
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 
23 #ifdef WIN32
24 # ifdef min
25 # undef min
26 # endif // min
27 # ifdef max
28 # undef max
29 # endif // max
30 #else // WIN32
31 # include <fcntl.h>
32 # include <sys/mman.h>
33 # include <unistd.h>
34 #endif // WIN32
35 
36 #include <algorithm>
37 #include <limits>
38 
39 namespace grn {
40 namespace dat {
41 
42 #ifdef WIN32
43 
44 FileImpl::FileImpl()
45  : ptr_(NULL),
46  size_(0),
47  file_(INVALID_HANDLE_VALUE),
48  map_(INVALID_HANDLE_VALUE),
49  addr_(NULL) {}
50 
51 FileImpl::~FileImpl() {
52  if (addr_ != NULL) {
53  ::UnmapViewOfFile(addr_);
54  }
55 
56  if (map_ != INVALID_HANDLE_VALUE) {
57  ::CloseHandle(map_);
58  }
59 
60  if (file_ != INVALID_HANDLE_VALUE) {
61  ::CloseHandle(file_);
62  }
63 }
64 
65 #else // WIN32
66 
67 FileImpl::FileImpl()
68  : ptr_(NULL),
69  size_(0),
70  fd_(-1),
71  addr_(MAP_FAILED),
72  length_(0) {}
73 
74 FileImpl::~FileImpl() {
75  if (addr_ != MAP_FAILED) {
76  ::munmap(addr_, length_);
77  }
78 
79  if (fd_ != -1) {
80  ::close(fd_);
81  }
82 }
83 
84 #endif // WIN32
85 
86 void FileImpl::create(const char *path, UInt64 size) {
87  GRN_DAT_THROW_IF(PARAM_ERROR, size == 0);
88  GRN_DAT_THROW_IF(PARAM_ERROR,
89  size > static_cast<UInt64>(std::numeric_limits< ::size_t>::max()));
90 
91  FileImpl new_impl;
92  new_impl.create_(path, size);
93  new_impl.swap(this);
94 }
95 
96 void FileImpl::open(const char *path) {
97  GRN_DAT_THROW_IF(PARAM_ERROR, path == NULL);
98  GRN_DAT_THROW_IF(PARAM_ERROR, path[0] == '\0');
99 
100  FileImpl new_impl;
101  new_impl.open_(path);
102  new_impl.swap(this);
103 }
104 
105 void FileImpl::close() {
106  FileImpl new_impl;
107  new_impl.swap(this);
108 }
109 
110 #ifdef WIN32
111 
112 void FileImpl::swap(FileImpl *rhs) {
113  std::swap(ptr_, rhs->ptr_);
114  std::swap(size_, rhs->size_);
115  std::swap(file_, rhs->file_);
116  std::swap(map_, rhs->map_);
117  std::swap(addr_, rhs->addr_);
118 }
119 
120 void FileImpl::create_(const char *path, UInt64 size) {
121  if ((path != NULL) && (path[0] != '\0')) {
122  file_ = ::CreateFileA(path, GENERIC_READ | GENERIC_WRITE,
123  FILE_SHARE_READ | FILE_SHARE_WRITE,
124  NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
125  GRN_DAT_THROW_IF(IO_ERROR, file_ == INVALID_HANDLE_VALUE);
126 
127  const LONG size_low = static_cast<LONG>(size & 0xFFFFFFFFU);
128  LONG size_high = static_cast<LONG>(size >> 32);
129  const DWORD file_pos = ::SetFilePointer(file_, size_low, &size_high,
130  FILE_BEGIN);
131  GRN_DAT_THROW_IF(IO_ERROR, (file_pos == INVALID_SET_FILE_POINTER) &&
132  (::GetLastError() != 0));
133  GRN_DAT_THROW_IF(IO_ERROR, ::SetEndOfFile(file_) == 0);
134 
135  map_ = ::CreateFileMapping(file_, NULL, PAGE_READWRITE, 0, 0, NULL);
136  GRN_DAT_THROW_IF(IO_ERROR, map_ == INVALID_HANDLE_VALUE);
137  } else {
138  const DWORD size_low = static_cast<DWORD>(size & 0xFFFFFFFFU);
139  const DWORD size_high = static_cast<DWORD>(size >> 32);
140 
141  map_ = ::CreateFileMapping(file_, NULL, PAGE_READWRITE,
142  size_high, size_low, NULL);
143  GRN_DAT_THROW_IF(IO_ERROR, map_ == INVALID_HANDLE_VALUE);
144  }
145 
146  addr_ = ::MapViewOfFile(map_, FILE_MAP_WRITE, 0, 0, 0);
147  GRN_DAT_THROW_IF(IO_ERROR, addr_ == NULL);
148 
149  ptr_ = addr_;
150  size_ = static_cast< ::size_t>(size);
151 }
152 
153 void FileImpl::open_(const char *path) {
154 #ifdef _MSC_VER
155  struct __stat64 st;
156  GRN_DAT_THROW_IF(IO_ERROR, ::_stat64(path, &st) == -1);
157 #else // _MSC_VER
158  struct _stat st;
159  GRN_DAT_THROW_IF(IO_ERROR, ::_stat(path, &st) == -1);
160 #endif // _MSC_VER
161  GRN_DAT_THROW_IF(IO_ERROR, st.st_size == 0);
162  GRN_DAT_THROW_IF(IO_ERROR,
163  static_cast<UInt64>(st.st_size) > std::numeric_limits< ::size_t>::max());
164 
165  file_ = ::CreateFileA(path, GENERIC_READ | GENERIC_WRITE,
166  FILE_SHARE_READ | FILE_SHARE_WRITE,
167  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
168  GRN_DAT_THROW_IF(IO_ERROR, file_ == NULL);
169 
170  map_ = ::CreateFileMapping(file_, NULL, PAGE_READWRITE, 0, 0, NULL);
171  GRN_DAT_THROW_IF(IO_ERROR, map_ == NULL);
172 
173  addr_ = ::MapViewOfFile(map_, FILE_MAP_WRITE, 0, 0, 0);
174  GRN_DAT_THROW_IF(IO_ERROR, addr_ == NULL);
175 
176  ptr_ = addr_;
177  size_ = static_cast< ::size_t>(st.st_size);
178 }
179 
180 #else // WIN32
181 
182 void FileImpl::swap(FileImpl *rhs) {
183  std::swap(ptr_, rhs->ptr_);
184  std::swap(size_, rhs->size_);
185  std::swap(fd_, rhs->fd_);
186  std::swap(addr_, rhs->addr_);
187  std::swap(length_, rhs->length_);
188 }
189 
190 void FileImpl::create_(const char *path, UInt64 size) {
191  GRN_DAT_THROW_IF(PARAM_ERROR,
192  size > static_cast<UInt64>(std::numeric_limits< ::off_t>::max()));
193 
194  if ((path != NULL) && (path[0] != '\0')) {
195  fd_ = ::open(path, O_RDWR | O_CREAT | O_TRUNC, 0666);
196  GRN_DAT_THROW_IF(IO_ERROR, fd_ == -1);
197 
198  const ::off_t file_size = static_cast< ::off_t>(size);
199  GRN_DAT_THROW_IF(IO_ERROR, ::ftruncate(fd_, file_size) == -1);
200  }
201 
202 #ifdef MAP_ANONYMOUS
203  const int flags = (fd_ == -1) ? (MAP_PRIVATE | MAP_ANONYMOUS) : MAP_SHARED;
204 #else // MAP_ANONYMOUS
205  const int flags = (fd_ == -1) ? (MAP_PRIVATE | MAP_ANON) : MAP_SHARED;
206 #endif // MAP_ANONYMOUS
207 
208  length_ = static_cast< ::size_t>(size);
209 #ifdef USE_MAP_HUGETLB
210  addr_ = ::mmap(NULL, length_, PROT_READ | PROT_WRITE,
211  flags | MAP_HUGETLB, fd_, 0);
212 #endif // USE_MAP_HUGETLB
213  if (addr_ == MAP_FAILED) {
214  addr_ = ::mmap(NULL, length_, PROT_READ | PROT_WRITE, flags, fd_, 0);
215  GRN_DAT_THROW_IF(IO_ERROR, addr_ == MAP_FAILED);
216  }
217 
218  ptr_ = addr_;
219  size_ = length_;
220 }
221 
222 void FileImpl::open_(const char *path) {
223  struct stat st;
224  GRN_DAT_THROW_IF(IO_ERROR, ::stat(path, &st) == -1);
225  GRN_DAT_THROW_IF(IO_ERROR, (st.st_mode & S_IFMT) != S_IFREG);
226  GRN_DAT_THROW_IF(IO_ERROR, st.st_size == 0);
227  GRN_DAT_THROW_IF(IO_ERROR,
228  static_cast<UInt64>(st.st_size) > std::numeric_limits< ::size_t>::max());
229 
230  fd_ = ::open(path, O_RDWR);
231  GRN_DAT_THROW_IF(IO_ERROR, fd_ == -1);
232 
233  length_ = static_cast<std::size_t>(st.st_size);
234  addr_ = ::mmap(NULL, length_, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0);
235  GRN_DAT_THROW_IF(IO_ERROR, addr_ == MAP_FAILED);
236 
237  ptr_ = addr_;
238  size_ = length_;
239 }
240 
241 #endif // WIN32
242 
243 } // namespace dat
244 } // namespace grn
Generated on Sun Nov 10 2013 09:49:02 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2