filesetup.c revision 1549441cdfecb2c1a4a8b8d494253859d67b4344
1#include <unistd.h> 2#include <fcntl.h> 3#include <string.h> 4#include <assert.h> 5#include <sys/stat.h> 6#include <sys/mman.h> 7 8#include "fio.h" 9#include "os.h" 10 11/* 12 * Check if the file exists and it's large enough. 13 */ 14static int file_ok(struct thread_data *td, struct fio_file *f) 15{ 16 struct stat st; 17 18 if (f->filetype != FIO_TYPE_FILE || 19 (td->io_ops->flags & FIO_DISKLESSIO)) 20 return 0; 21 22 if (lstat(f->file_name, &st) == -1) 23 return 1; 24 25 /* 26 * if it's a special file, size is always ok for now 27 */ 28 if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) 29 return 0; 30 if (st.st_size < (off_t) f->file_size) 31 return 1; 32 33 return 0; 34} 35 36static int create_file(struct thread_data *td, struct fio_file *f) 37{ 38 unsigned long long left; 39 unsigned int bs; 40 char *b; 41 int r; 42 43 f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644); 44 if (f->fd < 0) { 45 td_verror(td, errno, "open"); 46 return 1; 47 } 48 49 if (ftruncate(f->fd, f->file_size) == -1) { 50 td_verror(td, errno, "ftruncate"); 51 goto err; 52 } 53 54 if (posix_fallocate(f->fd, 0, f->file_size) < 0) { 55 td_verror(td, errno, "posix_fallocate"); 56 goto err; 57 } 58 59 b = malloc(td->max_bs[DDIR_WRITE]); 60 memset(b, 0, td->max_bs[DDIR_WRITE]); 61 62 left = f->file_size; 63 while (left && !td->terminate) { 64 bs = td->max_bs[DDIR_WRITE]; 65 if (bs > left) 66 bs = left; 67 68 r = write(f->fd, b, bs); 69 70 if (r == (int) bs) { 71 left -= bs; 72 continue; 73 } else { 74 if (r < 0) 75 td_verror(td, errno, "write"); 76 else 77 td_verror(td, EIO, "write"); 78 79 break; 80 } 81 } 82 83 if (td->terminate) 84 unlink(f->file_name); 85 else if (td->create_fsync) 86 fsync(f->fd); 87 88 free(b); 89 close(f->fd); 90 f->fd = -1; 91 return 0; 92err: 93 close(f->fd); 94 f->fd = -1; 95 return 1; 96} 97 98static int create_files(struct thread_data *td) 99{ 100 struct fio_file *f; 101 int err, need_create, can_extend; 102 unsigned int i; 103 104 for_each_file(td, f, i) { 105 if (f->filetype != FIO_TYPE_FILE) 106 continue; 107 108 f->file_size = td->total_file_size / td->nr_normal_files; 109 f->file_offset = td->start_offset; 110 } 111 112 /* 113 * unless specifically asked for overwrite, let normal io extend it 114 */ 115 can_extend = !td->overwrite && !(td->io_ops->flags & FIO_NOEXTEND); 116 if (can_extend) 117 return 0; 118 119 need_create = 0; 120 for_each_file(td, f, i) { 121 int file_there; 122 123 if (f->filetype != FIO_TYPE_FILE) 124 continue; 125 126 file_there = !file_ok(td, f); 127 128 if (file_there && td_write(td) && !td->overwrite) { 129 unlink(f->file_name); 130 file_there = 0; 131 } 132 133 need_create += !file_there; 134 } 135 136 if (!need_create) 137 return 0; 138 139 if (!td->total_file_size) { 140 log_err("Need size for create\n"); 141 td_verror(td, EINVAL, "file_size"); 142 return 1; 143 } 144 145 temp_stall_ts = 1; 146 fprintf(f_out, "%s: Laying out IO file(s) (%u x %LuMiB == %LuMiB)\n", 147 td->name, td->nr_normal_files, 148 (td->total_file_size >> 20) / td->nr_normal_files, 149 td->total_file_size >> 20); 150 151 err = 0; 152 for_each_file(td, f, i) { 153 /* 154 * Only unlink files that we created. 155 */ 156 f->flags &= ~FIO_FILE_UNLINK; 157 if (file_ok(td, f)) { 158 if (td->unlink) 159 f->flags |= FIO_FILE_UNLINK; 160 161 err = create_file(td, f); 162 if (err) 163 break; 164 } 165 } 166 167 temp_stall_ts = 0; 168 return err; 169} 170 171static int file_size(struct thread_data *td, struct fio_file *f) 172{ 173 struct stat st; 174 175 if (td->overwrite) { 176 if (fstat(f->fd, &st) == -1) { 177 td_verror(td, errno, "fstat"); 178 return 1; 179 } 180 181 f->real_file_size = st.st_size; 182 183 if (!f->file_size || f->file_size > f->real_file_size) 184 f->file_size = f->real_file_size; 185 } else 186 f->real_file_size = f->file_size; 187 188 return 0; 189} 190 191static int bdev_size(struct thread_data *td, struct fio_file *f) 192{ 193 unsigned long long bytes; 194 int r; 195 196 r = blockdev_size(f->fd, &bytes); 197 if (r) { 198 td_verror(td, r, "blockdev_size"); 199 return 1; 200 } 201 202 f->real_file_size = bytes; 203 204 /* 205 * no extend possibilities, so limit size to device size if too large 206 */ 207 if (!f->file_size || f->file_size > f->real_file_size) 208 f->file_size = f->real_file_size; 209 210 f->file_size -= f->file_offset; 211 return 0; 212} 213 214static int get_file_size(struct thread_data *td, struct fio_file *f) 215{ 216 int ret = 0; 217 218 if (f->filetype == FIO_TYPE_FILE) 219 ret = file_size(td, f); 220 else if (f->filetype == FIO_TYPE_BD) 221 ret = bdev_size(td, f); 222 else 223 f->real_file_size = -1; 224 225 if (ret) 226 return ret; 227 228 if (f->file_offset > f->real_file_size) { 229 log_err("%s: offset extends end (%Lu > %Lu)\n", td->name, f->file_offset, f->real_file_size); 230 return 1; 231 } 232 233 return 0; 234} 235 236int file_invalidate_cache(struct thread_data *td, struct fio_file *f) 237{ 238 int ret = 0; 239 240 if (td->odirect) 241 return 0; 242 243 /* 244 * FIXME: add blockdev flushing too 245 */ 246 if (f->mmap) 247 ret = madvise(f->mmap, f->file_size, MADV_DONTNEED); 248 else if (f->filetype == FIO_TYPE_FILE) { 249 ret = fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED); 250 } else if (f->filetype == FIO_TYPE_BD) { 251 ret = blockdev_invalidate_cache(f->fd); 252 } else if (f->filetype == FIO_TYPE_CHAR) 253 ret = 0; 254 255 if (ret < 0) { 256 td_verror(td, errno, "invalidate_cache"); 257 return 1; 258 } 259 260 return ret; 261} 262 263void generic_close_file(struct thread_data fio_unused *td, struct fio_file *f) 264{ 265 close(f->fd); 266 f->fd = -1; 267} 268 269int generic_open_file(struct thread_data *td, struct fio_file *f) 270{ 271 int flags = 0; 272 273 if (td->odirect) 274 flags |= OS_O_DIRECT; 275 if (td->sync_io) 276 flags |= O_SYNC; 277 278 if (td_write(td) || td_rw(td)) { 279 flags |= O_RDWR; 280 281 if (f->filetype == FIO_TYPE_FILE) 282 flags |= O_CREAT; 283 284 f->fd = open(f->file_name, flags, 0600); 285 } else { 286 if (f->filetype == FIO_TYPE_CHAR) 287 flags |= O_RDWR; 288 else 289 flags |= O_RDONLY; 290 291 f->fd = open(f->file_name, flags); 292 } 293 294 if (f->fd == -1) { 295 int __e = errno; 296 297 td_verror(td, __e, "open"); 298 if (__e == EINVAL && td->odirect) 299 log_err("fio: destination does not support O_DIRECT\n"); 300 return 1; 301 } 302 303 if (get_file_size(td, f)) 304 goto err; 305 306 if (td->invalidate_cache && file_invalidate_cache(td, f)) 307 goto err; 308 309 if (!td_random(td)) { 310 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) { 311 td_verror(td, errno, "fadvise"); 312 goto err; 313 } 314 } else { 315 if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) { 316 td_verror(td, errno, "fadvise"); 317 goto err; 318 } 319 } 320 321 return 0; 322err: 323 close(f->fd); 324 return 1; 325} 326 327int open_files(struct thread_data *td) 328{ 329 struct fio_file *f; 330 unsigned int i; 331 int err = 0; 332 333 for_each_file(td, f, i) { 334 err = td_io_open_file(td, f); 335 if (err) 336 break; 337 338 if (td->open_files == td->nr_open_files) 339 break; 340 } 341 342 if (!err) 343 return 0; 344 345 for_each_file(td, f, i) 346 td_io_close_file(td, f); 347 348 return err; 349} 350 351int setup_files(struct thread_data *td) 352{ 353 struct fio_file *f; 354 unsigned int i; 355 int err; 356 357 /* 358 * if ioengine defines a setup() method, it's responsible for 359 * setting up everything in the td->files[] area. 360 */ 361 if (td->io_ops->setup) 362 return td->io_ops->setup(td); 363 364 if (create_files(td)) 365 return 1; 366 367 err = open_files(td); 368 if (err) 369 return err; 370 371 /* 372 * Recalculate the total file size now that files are set up. 373 */ 374 td->total_file_size = 0; 375 for_each_file(td, f, i) 376 td->total_file_size += f->file_size; 377 378 td->total_file_size = (td->total_file_size * td->nr_files) / td->open_files; 379 380 td->io_size = td->total_file_size; 381 if (td->io_size == 0) { 382 log_err("%s: no io blocks\n", td->name); 383 td_verror(td, EINVAL, "total_file_size"); 384 return 1; 385 } 386 387 if (!td->zone_size) 388 td->zone_size = td->io_size; 389 390 td->total_io_size = td->io_size * td->loops; 391 392 for_each_file(td, f, i) 393 td_io_close_file(td, f); 394 395 return err; 396} 397 398void close_files(struct thread_data *td) 399{ 400 struct fio_file *f; 401 unsigned int i; 402 403 for_each_file(td, f, i) { 404 if (!f->file_name && (f->flags & FIO_FILE_UNLINK) && 405 f->filetype == FIO_TYPE_FILE) { 406 unlink(f->file_name); 407 free(f->file_name); 408 f->file_name = NULL; 409 } 410 411 td_io_close_file(td, f); 412 413 if (f->file_map) 414 free(f->file_map); 415 } 416 417 td->filename = NULL; 418 free(td->files); 419 td->files = NULL; 420 td->nr_files = 0; 421} 422 423static void get_file_type(struct fio_file *f) 424{ 425 struct stat sb; 426 427 f->filetype = FIO_TYPE_FILE; 428 429 if (!lstat(f->file_name, &sb)) { 430 if (S_ISBLK(sb.st_mode)) 431 f->filetype = FIO_TYPE_BD; 432 else if (S_ISCHR(sb.st_mode)) 433 f->filetype = FIO_TYPE_CHAR; 434 } 435} 436 437void add_file(struct thread_data *td, const char *fname) 438{ 439 int cur_files = td->open_files; 440 struct fio_file *f; 441 442 td->files = realloc(td->files, (cur_files + 1) * sizeof(*f)); 443 444 f = &td->files[cur_files]; 445 memset(f, 0, sizeof(*f)); 446 f->fd = -1; 447 f->file_name = strdup(fname); 448 449 get_file_type(f); 450 451 td->open_files++; 452 if (f->filetype == FIO_TYPE_FILE) 453 td->nr_normal_files++; 454} 455 456void get_file(struct fio_file *f) 457{ 458 f->references++; 459} 460 461void put_file(struct thread_data *td, struct fio_file *f) 462{ 463 if (!(f->flags & FIO_FILE_OPEN)) 464 return; 465 466 assert(f->references); 467 if (--f->references) 468 return; 469 470 if (td->io_ops->close_file) 471 td->io_ops->close_file(td, f); 472 td->nr_open_files--; 473 f->flags &= ~FIO_FILE_OPEN; 474} 475