4 * Copyright (C) 2005-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; only
9 * version 2.1 of the License.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include <sys/stat.h> /* For mode constants */
26 #include <fcntl.h> /* For O_* constants */
31 #include <lttng/align.h>
37 * Ensure we have the required amount of space available by writing 0
38 * into the entire buffer. Not doing so can trigger SIGBUS when going
39 * beyond the available shm space.
42 int zero_file(int fd
, size_t len
)
50 pagelen
= sysconf(_SC_PAGESIZE
);
53 zeropage
= calloc(pagelen
, 1);
57 while (len
> written
) {
59 retlen
= write(fd
, zeropage
,
60 min_t(size_t, pagelen
, len
- written
));
61 } while (retlen
== -1UL && errno
== EINTR
);
74 struct shm_object_table
*shm_object_table_create(size_t max_nb_obj
)
76 struct shm_object_table
*table
;
78 table
= zmalloc(sizeof(struct shm_object_table
) +
79 max_nb_obj
* sizeof(table
->objects
[0]));
80 table
->size
= max_nb_obj
;
85 struct shm_object
*_shm_object_table_alloc_shm(struct shm_object_table
*table
,
86 size_t memory_map_size
)
88 int shmfd
, waitfd
[2], ret
, i
, sigblocked
= 0;
89 struct shm_object
*obj
;
91 char tmp_name
[NAME_MAX
] = "/ust-shm-tmp-XXXXXX";
92 sigset_t all_sigs
, orig_sigs
;
94 if (table
->allocated_len
>= table
->size
)
96 obj
= &table
->objects
[table
->allocated_len
];
98 /* wait_fd: create pipe */
104 for (i
= 0; i
< 2; i
++) {
105 ret
= fcntl(waitfd
[i
], F_SETFD
, FD_CLOEXEC
);
111 /* The write end of the pipe needs to be non-blocking */
112 ret
= fcntl(waitfd
[1], F_SETFL
, O_NONBLOCK
);
117 memcpy(obj
->wait_fd
, waitfd
, sizeof(waitfd
));
119 /* shm_fd: create shm */
122 * Theoretically, we could leak a shm if the application crashes
123 * between open and unlink. Disable signals on this thread for
124 * increased safety against this scenario.
126 sigfillset(&all_sigs
);
127 ret
= pthread_sigmask(SIG_BLOCK
, &all_sigs
, &orig_sigs
);
129 PERROR("pthread_sigmask");
130 goto error_pthread_sigmask
;
135 * Allocate shm, and immediately unlink its shm oject, keeping
136 * only the file descriptor as a reference to the object. If it
137 * already exists (caused by short race window during which the
138 * global object exists in a concurrent shm_open), simply retry.
139 * We specifically do _not_ use the / at the beginning of the
140 * pathname so that some OS implementations can keep it local to
141 * the process (POSIX leaves this implementation-defined).
145 * Using mktemp filename with O_CREAT | O_EXCL open
148 (void) mktemp(tmp_name
);
149 if (tmp_name
[0] == '\0') {
153 shmfd
= shm_open(tmp_name
,
154 O_CREAT
| O_EXCL
| O_RDWR
, 0700);
155 } while (shmfd
< 0 && (errno
== EEXIST
|| errno
== EACCES
));
160 ret
= shm_unlink(tmp_name
);
161 if (ret
< 0 && errno
!= ENOENT
) {
162 PERROR("shm_unlink");
163 goto error_shm_release
;
166 ret
= pthread_sigmask(SIG_SETMASK
, &orig_sigs
, NULL
);
168 PERROR("pthread_sigmask");
169 goto error_sigmask_release
;
171 ret
= zero_file(shmfd
, memory_map_size
);
174 goto error_zero_file
;
176 ret
= ftruncate(shmfd
, memory_map_size
);
179 goto error_ftruncate
;
183 /* memory_map: mmap */
184 memory_map
= mmap(NULL
, memory_map_size
, PROT_READ
| PROT_WRITE
,
185 MAP_SHARED
, shmfd
, 0);
186 if (memory_map
== MAP_FAILED
) {
190 obj
->type
= SHM_OBJECT_SHM
;
191 obj
->memory_map
= memory_map
;
192 obj
->memory_map_size
= memory_map_size
;
193 obj
->allocated_len
= 0;
194 obj
->index
= table
->allocated_len
++;
202 error_sigmask_release
:
210 ret
= pthread_sigmask(SIG_SETMASK
, &orig_sigs
, NULL
);
212 PERROR("pthread_sigmask");
215 error_pthread_sigmask
:
217 for (i
= 0; i
< 2; i
++) {
218 ret
= close(waitfd
[i
]);
229 struct shm_object
*_shm_object_table_alloc_mem(struct shm_object_table
*table
,
230 size_t memory_map_size
)
232 struct shm_object
*obj
;
234 int waitfd
[2], i
, ret
;
236 if (table
->allocated_len
>= table
->size
)
238 obj
= &table
->objects
[table
->allocated_len
];
240 memory_map
= zmalloc(memory_map_size
);
244 /* wait_fd: create pipe */
250 for (i
= 0; i
< 2; i
++) {
251 ret
= fcntl(waitfd
[i
], F_SETFD
, FD_CLOEXEC
);
257 /* The write end of the pipe needs to be non-blocking */
258 ret
= fcntl(waitfd
[1], F_SETFL
, O_NONBLOCK
);
263 memcpy(obj
->wait_fd
, waitfd
, sizeof(waitfd
));
268 obj
->type
= SHM_OBJECT_MEM
;
269 obj
->memory_map
= memory_map
;
270 obj
->memory_map_size
= memory_map_size
;
271 obj
->allocated_len
= 0;
272 obj
->index
= table
->allocated_len
++;
277 for (i
= 0; i
< 2; i
++) {
278 ret
= close(waitfd
[i
]);
290 struct shm_object
*shm_object_table_alloc(struct shm_object_table
*table
,
291 size_t memory_map_size
,
292 enum shm_object_type type
)
296 return _shm_object_table_alloc_shm(table
, memory_map_size
);
298 return _shm_object_table_alloc_mem(table
, memory_map_size
);
305 struct shm_object
*shm_object_table_append_shm(struct shm_object_table
*table
,
306 int shm_fd
, int wakeup_fd
, uint32_t stream_nr
,
307 size_t memory_map_size
)
309 struct shm_object
*obj
;
313 if (table
->allocated_len
>= table
->size
)
315 /* streams _must_ be received in sequential order, else fail. */
316 if (stream_nr
+ 1 != table
->allocated_len
)
319 obj
= &table
->objects
[table
->allocated_len
];
321 /* wait_fd: set write end of the pipe. */
322 obj
->wait_fd
[0] = -1; /* read end is unset */
323 obj
->wait_fd
[1] = wakeup_fd
;
324 obj
->shm_fd
= shm_fd
;
326 ret
= fcntl(obj
->wait_fd
[1], F_SETFD
, FD_CLOEXEC
);
331 /* The write end of the pipe needs to be non-blocking */
332 ret
= fcntl(obj
->wait_fd
[1], F_SETFL
, O_NONBLOCK
);
338 /* memory_map: mmap */
339 memory_map
= mmap(NULL
, memory_map_size
, PROT_READ
| PROT_WRITE
,
340 MAP_SHARED
, shm_fd
, 0);
341 if (memory_map
== MAP_FAILED
) {
345 obj
->type
= SHM_OBJECT_SHM
;
346 obj
->memory_map
= memory_map
;
347 obj
->memory_map_size
= memory_map_size
;
348 obj
->allocated_len
= memory_map_size
;
349 obj
->index
= table
->allocated_len
++;
359 * Passing ownership of mem to object.
361 struct shm_object
*shm_object_table_append_mem(struct shm_object_table
*table
,
362 void *mem
, size_t memory_map_size
, int wakeup_fd
)
364 struct shm_object
*obj
;
367 if (table
->allocated_len
>= table
->size
)
369 obj
= &table
->objects
[table
->allocated_len
];
371 obj
->wait_fd
[0] = -1; /* read end is unset */
372 obj
->wait_fd
[1] = wakeup_fd
;
375 ret
= fcntl(obj
->wait_fd
[1], F_SETFD
, FD_CLOEXEC
);
380 /* The write end of the pipe needs to be non-blocking */
381 ret
= fcntl(obj
->wait_fd
[1], F_SETFL
, O_NONBLOCK
);
387 obj
->type
= SHM_OBJECT_MEM
;
388 obj
->memory_map
= mem
;
389 obj
->memory_map_size
= memory_map_size
;
390 obj
->allocated_len
= memory_map_size
;
391 obj
->index
= table
->allocated_len
++;
400 void shmp_object_destroy(struct shm_object
*obj
)
407 ret
= munmap(obj
->memory_map
, obj
->memory_map_size
);
412 ret
= close(obj
->shm_fd
);
417 for (i
= 0; i
< 2; i
++) {
418 if (obj
->wait_fd
[i
] < 0)
420 ret
= close(obj
->wait_fd
[i
]);
432 for (i
= 0; i
< 2; i
++) {
433 if (obj
->wait_fd
[i
] < 0)
435 ret
= close(obj
->wait_fd
[i
]);
441 free(obj
->memory_map
);
449 void shm_object_table_destroy(struct shm_object_table
*table
)
453 for (i
= 0; i
< table
->allocated_len
; i
++)
454 shmp_object_destroy(&table
->objects
[i
]);
459 * zalloc_shm - allocate memory within a shm object.
461 * Shared memory is already zeroed by shmget.
462 * *NOT* multithread-safe (should be protected by mutex).
463 * Returns a -1, -1 tuple on error.
465 struct shm_ref
zalloc_shm(struct shm_object
*obj
, size_t len
)
468 struct shm_ref shm_ref_error
= { -1, -1 };
470 if (obj
->memory_map_size
- obj
->allocated_len
< len
)
471 return shm_ref_error
;
472 ref
.index
= obj
->index
;
473 ref
.offset
= obj
->allocated_len
;
474 obj
->allocated_len
+= len
;
478 void align_shm(struct shm_object
*obj
, size_t align
)
480 size_t offset_len
= offset_align(obj
->allocated_len
, align
);
481 obj
->allocated_len
+= offset_len
;
This page took 0.054327 seconds and 4 git commands to generate.