memory.c

   1 /*
   2  * Memory helpers
   3  */
   4 #include <unistd.h>
   5 #include <sys/shm.h>
   6 #include <sys/mman.h>
   7
   8 #include "fio.h"
   9
  10 static void *pinned_mem;
  11
  12 void fio_unpin_memory(void)
  13 {
  14         if (pinned_mem) {
  15                 if (munlock(pinned_mem, mlock_size) < 0)
  16                         perror("munlock");
  17                 munmap(pinned_mem, mlock_size);
  18                 pinned_mem = NULL;
  19         }
  20 }
  21
  22 int fio_pin_memory(void)
  23 {
  24         unsigned long long phys_mem;
  25
  26         if (!mlock_size)
  27                 return 0;
  28
  29         /*
  30          * Don't allow mlock of more than real_mem-128MB
  31          */
  32         phys_mem = os_phys_mem();
  33         if (phys_mem) {
  34                 if ((mlock_size + 128 * 1024 * 1024) > phys_mem) {
  35                         mlock_size = phys_mem - 128 * 1024 * 1024;
  36                         log_info("fio: limiting mlocked memory to %lluMiB\n", mlock_size >> 20);
  37                 }
  38         }
  39
  40         pinned_mem = mmap(NULL, mlock_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | OS_MAP_ANON, 0, 0);
  41         if (pinned_mem == MAP_FAILED) {
  42                 perror("malloc locked mem");
  43                 pinned_mem = NULL;
  44                 return 1;
  45         }
  46         if (mlock(pinned_mem, mlock_size) < 0) {
  47                 perror("mlock");
  48                 munmap(pinned_mem, mlock_size);
  49                 pinned_mem = NULL;
  50                 return 1;
  51         }
  52
  53         return 0;
  54 }
  55
  56 /*
  57  * Setup the buffer area we need for io.
  58  */
  59 int allocate_io_mem(struct thread_data *td)
  60 {
  61         if (td->o.mem_type == MEM_MALLOC)
  62                 td->orig_buffer = malloc(td->orig_buffer_size);
  63         else if (td->o.mem_type == MEM_SHM || td->o.mem_type == MEM_SHMHUGE) {
  64                 int flags = IPC_CREAT | SHM_R | SHM_W;
  65
  66                 if (td->o.mem_type == MEM_SHMHUGE)
  67                         flags |= SHM_HUGETLB;
  68
  69                 td->shm_id = shmget(IPC_PRIVATE, td->orig_buffer_size, flags);
  70                 if (td->shm_id < 0) {
  71                         td_verror(td, errno, "shmget");
  72                         if (geteuid() != 0 && errno == ENOMEM)
  73                                 log_err("fio: you may need to run this job as root\n");
  74                         if (errno == EINVAL && td->o.mem_type == MEM_SHMHUGE)
  75                                 log_err("fio: check that you have free huge pages and that hugepage-size is correct.\n");
  76
  77                         return 1;
  78                 }
  79
  80                 td->orig_buffer = shmat(td->shm_id, NULL, 0);
  81                 if (td->orig_buffer == (void *) -1) {
  82                         td_verror(td, errno, "shmat");
  83                         td->orig_buffer = NULL;
  84                         return 1;
  85                 }
  86         } else if (td->o.mem_type == MEM_MMAP ||
  87                    td->o.mem_type == MEM_MMAPHUGE) {
  88                 int flags = MAP_PRIVATE;
  89
  90                 td->mmapfd = 0;
  91
  92                 if (td->mmapfile) {
  93                         td->mmapfd = open(td->mmapfile, O_RDWR|O_CREAT, 0644);
  94
  95                         if (td->mmapfd < 0) {
  96                                 td_verror(td, errno, "open mmap file");
  97                                 td->orig_buffer = NULL;
  98                                 return 1;
  99                         }
 100                         if (ftruncate(td->mmapfd, td->orig_buffer_size) < 0) {
 101                                 td_verror(td, errno, "truncate mmap file");
 102                                 td->orig_buffer = NULL;
 103                                 return 1;
 104                         }
 105                 } else
 106                         flags |= OS_MAP_ANON;
 107
 108                 td->orig_buffer = mmap(NULL, td->orig_buffer_size, PROT_READ | PROT_WRITE, flags, td->mmapfd, 0);
 109                 if (td->orig_buffer == MAP_FAILED) {
 110                         td_verror(td, errno, "mmap");
 111                         td->orig_buffer = NULL;
 112                         if (td->mmapfd) {
 113                                 close(td->mmapfd);
 114                                 unlink(td->mmapfile);
 115                         }
 116
 117                         return 1;
 118                 }
 119         }
 120
 121         return 0;
 122 }
 123
 124 void free_io_mem(struct thread_data *td)
 125 {
 126         if (td->o.mem_type == MEM_MALLOC)
 127                 free(td->orig_buffer);
 128         else if (td->o.mem_type == MEM_SHM || td->o.mem_type == MEM_SHMHUGE) {
 129                 struct shmid_ds sbuf;
 130
 131                 shmdt(td->orig_buffer);
 132                 shmctl(td->shm_id, IPC_RMID, &sbuf);
 133         } else if (td->o.mem_type == MEM_MMAP ||
 134                    td->o.mem_type == MEM_MMAPHUGE) {
 135                 munmap(td->orig_buffer, td->orig_buffer_size);
 136                 if (td->mmapfile) {
 137                         close(td->mmapfd);
 138                         unlink(td->mmapfile);
 139                         free(td->mmapfile);
 140                 }
 141         } else
 142                 log_err("Bad memory type %u\n", td->o.mem_type);
 143
 144         td->orig_buffer = NULL;
 145 }