Fix: fd-tracker: error path lead to null dereference of handle
[lttng-tools.git] / src / common / fd-tracker / fd-tracker.c
CommitLineData
df038819
JG
1/*
2 * Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18#include <urcu.h>
19#include <urcu/list.h>
20#include <urcu/rculfhash.h>
21
22#include <sys/stat.h>
23#include <sys/types.h>
24#include <fcntl.h>
25#include <stdbool.h>
26#include <pthread.h>
27#include <inttypes.h>
28
29#include "common/macros.h"
30#include "common/error.h"
31#include "common/defaults.h"
32#include "common/hashtable/utils.h"
33#include "common/hashtable/hashtable.h"
34
35#include "fd-tracker.h"
874a3441 36#include "inode.h"
df038819
JG
37
38/* Tracker lock must be taken by the user. */
39#define TRACKED_COUNT(tracker) \
40 (tracker->count.suspendable.active + \
41 tracker->count.suspendable.suspended + \
42 tracker->count.unsuspendable)
43
44/* Tracker lock must be taken by the user. */
45#define ACTIVE_COUNT(tracker) \
46 (tracker->count.suspendable.active + \
47 tracker->count.unsuspendable)
48
49/* Tracker lock must be taken by the user. */
50#define SUSPENDED_COUNT(tracker) \
51 (tracker->count.suspendable.suspended)
52
53/* Tracker lock must be taken by the user. */
54#define SUSPENDABLE_COUNT(tracker) \
55 (tracker->count.suspendable.active + \
56 tracker->count.suspendable.suspended)
57
58/* Tracker lock must be taken by the user. */
59#define UNSUSPENDABLE_COUNT(tracker) \
60 (tracker->count.unsuspendable)
61
62struct fd_tracker {
63 pthread_mutex_t lock;
64 struct {
65 struct {
66 unsigned int active;
67 unsigned int suspended;
68 } suspendable;
69 unsigned int unsuspendable;
70 } count;
71 unsigned int capacity;
72 struct {
73 uint64_t uses;
74 uint64_t misses;
75 /* Failures to suspend or restore fs handles. */
76 uint64_t errors;
77 } stats;
78 /*
79 * The head of the active_handles list is always the least recently
80 * used active handle. When an handle is used, it is removed from the
81 * list and added to the end. When a file has to be suspended, the
82 * first element in the list is "popped", suspended, and added to the
83 * list of suspended handles.
84 */
85 struct cds_list_head active_handles;
86 struct cds_list_head suspended_handles;
87 struct cds_lfht *unsuspendable_fds;
874a3441 88 struct lttng_inode_registry *inode_registry;
df038819
JG
89};
90
91struct open_properties {
df038819
JG
92 int flags;
93 struct {
94 bool is_set;
95 mode_t value;
96 } mode;
97};
98
99/*
100 * A fs_handle is not ref-counted. Therefore, it is assumed that a
101 * handle is never in-use while it is being reclaimed. It can be
102 * shared by multiple threads, but external synchronization is required
103 * to ensure it is not still being used when it is reclaimed (close method).
104 * In this respect, it is not different from a regular file descriptor.
105 *
106 * The fs_handle lock always nests _within_ the tracker's lock.
107 */
108struct fs_handle {
109 pthread_mutex_t lock;
110 /*
111 * Weak reference to the tracker. All fs_handles are assumed to have
112 * been closed at the moment of the destruction of the fd_tracker.
113 */
114 struct fd_tracker *tracker;
115 struct open_properties properties;
874a3441 116 struct lttng_inode *inode;
df038819
JG
117 int fd;
118 /* inode number of the file at the time of the handle's creation. */
119 uint64_t ino;
120 bool in_use;
121 /* Offset to which the file should be restored. */
122 off_t offset;
123 struct cds_list_head handles_list_node;
124};
125
126struct unsuspendable_fd {
127 /*
128 * Accesses are only performed through the tracker, which is protected
129 * by its own lock.
130 */
131 int fd;
132 char *name;
133 struct cds_lfht_node tracker_node;
134 struct rcu_head rcu_head;
135};
136
137static struct {
138 pthread_mutex_t lock;
139 bool initialized;
140 unsigned long value;
141} seed = {
142 .lock = PTHREAD_MUTEX_INITIALIZER,
143};
144
145static int match_fd(struct cds_lfht_node *node, const void *key);
146static void unsuspendable_fd_destroy(struct unsuspendable_fd *entry);
147static struct unsuspendable_fd *unsuspendable_fd_create(const char *name,
148 int fd);
874a3441
JG
149static int open_from_properties(const char *path,
150 struct open_properties *properties);
df038819
JG
151
152static void fs_handle_log(struct fs_handle *handle);
153static int fs_handle_suspend(struct fs_handle *handle);
154static int fs_handle_restore(struct fs_handle *handle);
155
156static void fd_tracker_track(struct fd_tracker *tracker,
157 struct fs_handle *handle);
158static void fd_tracker_untrack(struct fd_tracker *tracker,
159 struct fs_handle *handle);
160static int fd_tracker_suspend_handles(struct fd_tracker *tracker,
161 unsigned int count);
162static int fd_tracker_restore_handle(struct fd_tracker *tracker,
163 struct fs_handle *handle);
164
165/* Match function of the tracker's unsuspendable_fds hash table. */
166static
167int match_fd(struct cds_lfht_node *node, const void *key)
168{
169 struct unsuspendable_fd *entry =
170 caa_container_of(node, struct unsuspendable_fd, tracker_node);
171
172 return hash_match_key_ulong((void *) (unsigned long) entry->fd,
173 (void *) key);
174}
175
176static
177void delete_unsuspendable_fd(struct rcu_head *head)
178{
179 struct unsuspendable_fd *fd = caa_container_of(head,
180 struct unsuspendable_fd, rcu_head);
181
182 free(fd->name);
183 free(fd);
184}
185
186static
187void unsuspendable_fd_destroy(struct unsuspendable_fd *entry)
188{
189 if (!entry) {
190 return;
191 }
192 call_rcu(&entry->rcu_head, delete_unsuspendable_fd);
193}
194
195static
196struct unsuspendable_fd *unsuspendable_fd_create(const char *name, int fd)
197{
198 struct unsuspendable_fd *entry =
199 zmalloc(sizeof(*entry));
200
201 if (!entry) {
202 goto error;
203 }
204 if (name) {
205 entry->name = strdup(name);
206 if (!entry->name) {
207 goto error;
208 }
209 }
210 cds_lfht_node_init(&entry->tracker_node);
211 entry->fd = fd;
212 return entry;
213error:
214 unsuspendable_fd_destroy(entry);
215 return NULL;
216}
217
218static
219void fs_handle_log(struct fs_handle *handle)
220{
874a3441
JG
221 const char *path;
222
df038819 223 pthread_mutex_lock(&handle->lock);
874a3441
JG
224 path = lttng_inode_get_path(handle->inode);
225
df038819
JG
226 if (handle->fd >= 0) {
227 DBG_NO_LOC(" %s [active, fd %d%s]",
874a3441 228 path,
df038819
JG
229 handle->fd,
230 handle->in_use ? ", in use" : "");
231 } else {
874a3441 232 DBG_NO_LOC(" %s [suspended]", path);
df038819
JG
233 }
234 pthread_mutex_unlock(&handle->lock);
235}
236
874a3441 237/* Tracker lock must be held by the caller. */
df038819
JG
238static
239int fs_handle_suspend(struct fs_handle *handle)
240{
241 int ret = 0;
242 struct stat fs_stat;
874a3441 243 const char *path;
df038819
JG
244
245 pthread_mutex_lock(&handle->lock);
874a3441 246 path = lttng_inode_get_path(handle->inode);
df038819
JG
247 assert(handle->fd >= 0);
248 if (handle->in_use) {
249 /* This handle can't be suspended as it is currently in use. */
250 ret = -EAGAIN;
251 goto end;
252 }
253
874a3441 254 ret = stat(path, &fs_stat);
df038819
JG
255 if (ret) {
256 PERROR("Filesystem handle to %s cannot be suspended as stat() failed",
874a3441 257 path);
df038819
JG
258 ret = -errno;
259 goto end;
260 }
261
262 if (fs_stat.st_ino != handle->ino) {
263 /* Don't suspend as the handle would not be restorable. */
264 WARN("Filesystem handle to %s cannot be suspended as its inode changed",
874a3441 265 path);
df038819
JG
266 ret = -ENOENT;
267 goto end;
268 }
269
270 handle->offset = lseek(handle->fd, 0, SEEK_CUR);
271 if (handle->offset == -1) {
272 WARN("Filesystem handle to %s cannot be suspended as lseek() failed to sample its current position",
874a3441 273 path);
df038819
JG
274 ret = -errno;
275 goto end;
276 }
277
278 ret = close(handle->fd);
279 if (ret) {
280 PERROR("Filesystem handle to %s cannot be suspended as close() failed",
874a3441 281 path);
df038819
JG
282 ret = -errno;
283 goto end;
284 }
285 DBG("Suspended filesystem handle to %s (fd %i) at position %" PRId64,
874a3441 286 path, handle->fd, handle->offset);
df038819
JG
287 handle->fd = -1;
288end:
289 if (ret) {
290 handle->tracker->stats.errors++;
291 }
292 pthread_mutex_unlock(&handle->lock);
293 return ret;
294}
295
296/* Caller must hold the tracker and handle's locks. */
297static
298int fs_handle_restore(struct fs_handle *handle)
299{
300 int ret, fd = -1;
874a3441 301 const char *path = lttng_inode_get_path(handle->inode);
df038819
JG
302
303 assert(handle->fd == -1);
874a3441
JG
304 assert(path);
305 ret = open_from_properties(path,
306 &handle->properties);
df038819
JG
307 if (ret < 0) {
308 PERROR("Failed to restore filesystem handle to %s, open() failed",
874a3441 309 path);
df038819
JG
310 ret = -errno;
311 goto end;
312 }
313 fd = ret;
314
315 ret = lseek(fd, handle->offset, SEEK_SET);
316 if (ret < 0) {
317 PERROR("Failed to restore filesystem handle to %s, lseek() failed",
874a3441 318 path);
df038819
JG
319 ret = -errno;
320 goto end;
321 }
322 DBG("Restored filesystem handle to %s (fd %i) at position %" PRId64,
874a3441 323 path, fd, handle->offset);
df038819
JG
324 ret = 0;
325 handle->fd = fd;
326 fd = -1;
327end:
328 if (fd >= 0) {
329 (void) close(fd);
330 }
331 return ret;
332}
333
334static
874a3441 335int open_from_properties(const char *path, struct open_properties *properties)
df038819
JG
336{
337 int ret;
338
339 /*
340 * open() ignores the 'flags' parameter unless the O_CREAT or O_TMPFILE
341 * flags are set. O_TMPFILE would not make sense in the context of a
342 * suspendable fs_handle as it would not be restorable (see OPEN(2)),
343 * thus it is ignored here.
344 */
345 if ((properties->flags & O_CREAT) && properties->mode.is_set) {
874a3441 346 ret = open(path, properties->flags,
df038819
JG
347 properties->mode.value);
348 } else {
874a3441 349 ret = open(path, properties->flags);
df038819
JG
350 }
351 /*
352 * Some flags should not be used beyond the initial open() of a
353 * restorable file system handle. O_CREAT and O_TRUNC must
354 * be cleared since it would be unexpected to re-use them
355 * when the handle is retored:
356 * - O_CREAT should not be needed as the file has been created
357 * on the initial call to open(),
358 * - O_TRUNC would destroy the file's contents by truncating it
359 * to length 0.
360 */
361 properties->flags &= ~(O_CREAT | O_TRUNC);
362 if (ret < 0) {
363 ret = -errno;
364 goto end;
365 }
366end:
367 return ret;
368}
369
370struct fd_tracker *fd_tracker_create(unsigned int capacity)
371{
372 struct fd_tracker *tracker = zmalloc(sizeof(struct fd_tracker));
373
374 if (!tracker) {
375 goto end;
376 }
377
378 pthread_mutex_lock(&seed.lock);
379 if (!seed.initialized) {
380 seed.value = (unsigned long) time(NULL);
381 seed.initialized = true;
382 }
383 pthread_mutex_unlock(&seed.lock);
384
385 CDS_INIT_LIST_HEAD(&tracker->active_handles);
386 CDS_INIT_LIST_HEAD(&tracker->suspended_handles);
387 tracker->capacity = capacity;
388 tracker->unsuspendable_fds = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
389 CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
874a3441
JG
390 if (!tracker->unsuspendable_fds) {
391 ERR("Failed to create fd-tracker's unsuspendable_fds hash table");
392 goto error;
393 }
394 tracker->inode_registry = lttng_inode_registry_create();
395 if (!tracker->inode_registry) {
396 ERR("Failed to create fd-tracker's inode registry");
397 goto error;
398 }
df038819
JG
399 DBG("File descriptor tracker created with a limit of %u simultaneously-opened FDs",
400 capacity);
401end:
402 return tracker;
874a3441
JG
403error:
404 fd_tracker_destroy(tracker);
405 return NULL;
df038819
JG
406}
407
408void fd_tracker_log(struct fd_tracker *tracker)
409{
410 struct fs_handle *handle;
411 struct unsuspendable_fd *unsuspendable_fd;
412 struct cds_lfht_iter iter;
413
414 pthread_mutex_lock(&tracker->lock);
415 DBG_NO_LOC("File descriptor tracker");
416 DBG_NO_LOC(" Stats:");
417 DBG_NO_LOC(" uses: %" PRIu64, tracker->stats.uses);
418 DBG_NO_LOC(" misses: %" PRIu64, tracker->stats.misses);
419 DBG_NO_LOC(" errors: %" PRIu64, tracker->stats.errors);
420 DBG_NO_LOC(" Tracked: %u", TRACKED_COUNT(tracker));
421 DBG_NO_LOC(" active: %u", ACTIVE_COUNT(tracker));
422 DBG_NO_LOC(" suspendable: %u", SUSPENDABLE_COUNT(tracker));
423 DBG_NO_LOC(" unsuspendable: %u", UNSUSPENDABLE_COUNT(tracker));
424 DBG_NO_LOC(" suspended: %u", SUSPENDED_COUNT(tracker));
425 DBG_NO_LOC(" capacity: %u", tracker->capacity);
426
427 DBG_NO_LOC(" Tracked suspendable file descriptors");
428 cds_list_for_each_entry(handle, &tracker->active_handles,
429 handles_list_node) {
430 fs_handle_log(handle);
431 }
432 cds_list_for_each_entry(handle, &tracker->suspended_handles,
433 handles_list_node) {
434 fs_handle_log(handle);
435 }
436 if (!SUSPENDABLE_COUNT(tracker)) {
437 DBG_NO_LOC(" None");
438 }
439
440 DBG_NO_LOC(" Tracked unsuspendable file descriptors");
441 rcu_read_lock();
442 cds_lfht_for_each_entry(tracker->unsuspendable_fds, &iter,
443 unsuspendable_fd, tracker_node) {
444 DBG_NO_LOC(" %s [active, fd %d]", unsuspendable_fd->name ? : "Unnamed",
445 unsuspendable_fd->fd);
446 }
447 rcu_read_unlock();
448 if (!UNSUSPENDABLE_COUNT(tracker)) {
449 DBG_NO_LOC(" None");
450 }
451
452 pthread_mutex_unlock(&tracker->lock);
453}
454
455int fd_tracker_destroy(struct fd_tracker *tracker)
456{
457 int ret = 0;
458
459 /*
460 * Refuse to destroy the tracker as fs_handles may still old
461 * weak references to the tracker.
462 */
463 pthread_mutex_lock(&tracker->lock);
464 if (TRACKED_COUNT(tracker)) {
465 ERR("A file descriptor leak has been detected: %u tracked file descriptors are still being tracked",
466 TRACKED_COUNT(tracker));
467 pthread_mutex_unlock(&tracker->lock);
468 fd_tracker_log(tracker);
469 ret = -1;
470 goto end;
471 }
472 pthread_mutex_unlock(&tracker->lock);
473
874a3441
JG
474 if (tracker->unsuspendable_fds) {
475 ret = cds_lfht_destroy(tracker->unsuspendable_fds, NULL);
476 assert(!ret);
477 }
660a216c
JG
478
479 lttng_inode_registry_destroy(tracker->inode_registry);
df038819
JG
480 pthread_mutex_destroy(&tracker->lock);
481 free(tracker);
482end:
483 return ret;
484}
485
486struct fs_handle *fd_tracker_open_fs_handle(struct fd_tracker *tracker,
487 const char *path, int flags, mode_t *mode)
488{
489 int ret;
490 struct fs_handle *handle = NULL;
491 struct stat fd_stat;
492 struct open_properties properties = {
df038819
JG
493 .flags = flags,
494 .mode.is_set = !!mode,
495 .mode.value = mode ? *mode : 0,
496 };
497
df038819
JG
498 pthread_mutex_lock(&tracker->lock);
499 if (ACTIVE_COUNT(tracker) == tracker->capacity) {
500 if (tracker->count.suspendable.active > 0) {
501 ret = fd_tracker_suspend_handles(tracker, 1);
502 if (ret) {
19380ea8 503 goto end;
df038819
JG
504 }
505 } else {
506 /*
507 * There are not enough active suspendable file
19380ea8
JG
508 * descriptors to open a new fd and still accommodate
509 * the tracker's capacity.
df038819
JG
510 */
511 WARN("Cannot open file system handle, too many unsuspendable file descriptors are opened (%u)",
512 tracker->count.unsuspendable);
19380ea8 513 goto end;
df038819
JG
514 }
515 }
516
517 handle = zmalloc(sizeof(*handle));
518 if (!handle) {
519 goto end;
520 }
660a216c 521 handle->tracker = tracker;
df038819
JG
522
523 ret = pthread_mutex_init(&handle->lock, NULL);
524 if (ret) {
525 PERROR("Failed to initialize handle mutex while creating fs handle");
19380ea8 526 goto error_mutex_init;
df038819
JG
527 }
528
874a3441 529 handle->fd = open_from_properties(path, &properties);
df038819
JG
530 if (handle->fd < 0) {
531 PERROR("Failed to open fs handle to %s, open() returned", path);
19380ea8 532 goto error;
df038819
JG
533 }
534
535 handle->properties = properties;
874a3441
JG
536
537 handle->inode = lttng_inode_registry_get_inode(tracker->inode_registry,
538 handle->fd, path);
539 if (!handle->inode) {
540 ERR("Failed to get lttng_inode corresponding to file %s",
541 path);
19380ea8 542 goto error;
874a3441 543 }
df038819
JG
544
545 if (fstat(handle->fd, &fd_stat)) {
546 PERROR("Failed to retrieve file descriptor inode while creating fs handle, fstat() returned");
19380ea8 547 goto error;
df038819
JG
548 }
549 handle->ino = fd_stat.st_ino;
550
551 fd_tracker_track(tracker, handle);
df038819 552end:
19380ea8 553 pthread_mutex_unlock(&tracker->lock);
df038819 554 return handle;
19380ea8 555error:
660a216c
JG
556 if (handle->inode) {
557 lttng_inode_put(handle->inode);
558 }
19380ea8
JG
559 pthread_mutex_destroy(&handle->lock);
560error_mutex_init:
660a216c 561 free(handle);
df038819
JG
562 handle = NULL;
563 goto end;
564}
565
566/* Caller must hold the tracker's lock. */
567static
568int fd_tracker_suspend_handles(struct fd_tracker *tracker,
569 unsigned int count)
570{
571 unsigned int left_to_close = count;
572 struct fs_handle *handle, *tmp;
573
574 cds_list_for_each_entry_safe(handle, tmp, &tracker->active_handles,
575 handles_list_node) {
576 int ret;
577
578 fd_tracker_untrack(tracker, handle);
579 ret = fs_handle_suspend(handle);
580 fd_tracker_track(tracker, handle);
581 if (!ret) {
582 left_to_close--;
583 }
584
585 if (!left_to_close) {
586 break;
587 }
588 }
589 return left_to_close ? -EMFILE : 0;
590}
591
592int fd_tracker_open_unsuspendable_fd(struct fd_tracker *tracker,
593 int *out_fds, const char **names, unsigned int fd_count,
594 fd_open_cb open, void *user_data)
595{
596 int ret, user_ret, i, fds_to_suspend;
597 unsigned int active_fds;
598 struct unsuspendable_fd *entries[fd_count];
599
600 memset(entries, 0, sizeof(entries));
601
602 pthread_mutex_lock(&tracker->lock);
603
604 active_fds = ACTIVE_COUNT(tracker);
605 fds_to_suspend = (int) active_fds + (int) fd_count - (int) tracker->capacity;
606 if (fds_to_suspend > 0) {
607 if (fds_to_suspend <= tracker->count.suspendable.active) {
608 ret = fd_tracker_suspend_handles(tracker, fds_to_suspend);
609 if (ret) {
610 goto end;
611 }
612 } else {
613 /*
614 * There are not enough active suspendable file
615 * descriptors to open a new fd and still accomodate the
616 * tracker's capacity.
617 */
618 WARN("Cannot open unsuspendable fd, too many unsuspendable file descriptors are opened (%u)",
619 tracker->count.unsuspendable);
620 ret = -EMFILE;
621 goto end;
622 }
623 }
624
625 user_ret = open(user_data, out_fds);
626 if (user_ret) {
627 ret = user_ret;
628 goto end;
629 }
630
631 /*
632 * Add the fds returned by the user's callback to the hashtable
633 * of unsuspendable fds.
634 */
635 for (i = 0; i < fd_count; i++) {
636 struct unsuspendable_fd *entry =
637 unsuspendable_fd_create(names ? names[i] : NULL,
638 out_fds[i]);
639
640 if (!entry) {
641 ret = -1;
642 goto end_free_entries;
643 }
644 entries[i] = entry;
645 }
646
647 rcu_read_lock();
648 for (i = 0; i < fd_count; i++) {
649 struct cds_lfht_node *node;
650 struct unsuspendable_fd *entry = entries[i];
651
652 node = cds_lfht_add_unique(
653 tracker->unsuspendable_fds,
654 hash_key_ulong((void *) (unsigned long) out_fds[i],
655 seed.value),
656 match_fd,
657 (void *) (unsigned long) out_fds[i],
658 &entry->tracker_node);
659
660 if (node != &entry->tracker_node) {
661 ret = -EEXIST;
662 rcu_read_unlock();
663 goto end_free_entries;
664 }
665 entries[i] = NULL;
666 }
667 tracker->count.unsuspendable += fd_count;
668 rcu_read_unlock();
669 ret = user_ret;
670end:
671 pthread_mutex_unlock(&tracker->lock);
672 return ret;
673end_free_entries:
674 for (i = 0; i < fd_count; i++) {
675 unsuspendable_fd_destroy(entries[i]);
676 }
677 goto end;
678}
679
680int fd_tracker_close_unsuspendable_fd(struct fd_tracker *tracker,
681 int *fds_in, unsigned int fd_count, fd_close_cb close,
682 void *user_data)
683{
684 int i, ret, user_ret;
685 int fds[fd_count];
686
687 /*
688 * Maintain a local copy of fds_in as the user's callback may modify its
689 * contents (e.g. setting the fd(s) to -1 after close).
690 */
691 memcpy(fds, fds_in, sizeof(*fds) * fd_count);
692
693 pthread_mutex_lock(&tracker->lock);
694 rcu_read_lock();
695
696 /* Let the user close the file descriptors. */
697 user_ret = close(user_data, fds_in);
698 if (user_ret) {
699 ret = user_ret;
700 goto end;
701 }
702
703 /* Untrack the fds that were just closed by the user's callback. */
704 for (i = 0; i < fd_count; i++) {
705 struct cds_lfht_node *node;
706 struct cds_lfht_iter iter;
707 struct unsuspendable_fd *entry;
708
709 cds_lfht_lookup(tracker->unsuspendable_fds,
710 hash_key_ulong((void *) (unsigned long) fds[i],
711 seed.value),
712 match_fd,
713 (void *) (unsigned long) fds[i],
714 &iter);
715 node = cds_lfht_iter_get_node(&iter);
716 if (!node) {
717 /* Unknown file descriptor. */
718 WARN("Untracked file descriptor %d passed to fd_tracker_close_unsuspendable_fd()",
719 fds[i]);
720 ret = -EINVAL;
721 goto end;
722 }
723 entry = caa_container_of(node,
724 struct unsuspendable_fd,
725 tracker_node);
726
727 cds_lfht_del(tracker->unsuspendable_fds, node);
728 unsuspendable_fd_destroy(entry);
729 fds[i] = -1;
730 }
731
732 tracker->count.unsuspendable -= fd_count;
733 ret = 0;
734end:
735 rcu_read_unlock();
736 pthread_mutex_unlock(&tracker->lock);
737 return ret;
738}
739
740/* Caller must have taken the tracker's and handle's locks. */
741static
742void fd_tracker_track(struct fd_tracker *tracker, struct fs_handle *handle)
743{
744 if (handle->fd >= 0) {
745 tracker->count.suspendable.active++;
746 cds_list_add_tail(&handle->handles_list_node,
747 &tracker->active_handles);
748 } else {
749 tracker->count.suspendable.suspended++;
750 cds_list_add_tail(&handle->handles_list_node,
751 &tracker->suspended_handles);
752 }
753}
754
755/* Caller must have taken the tracker's and handle's locks. */
756static
757void fd_tracker_untrack(struct fd_tracker *tracker, struct fs_handle *handle)
758{
759 if (handle->fd >= 0) {
760 tracker->count.suspendable.active--;
761 } else {
762 tracker->count.suspendable.suspended--;
763 }
764 cds_list_del(&handle->handles_list_node);
765}
766
767/* Caller must have taken the tracker's and handle's locks. */
768static
769int fd_tracker_restore_handle(struct fd_tracker *tracker,
770 struct fs_handle *handle)
771{
772 int ret;
773
774 fd_tracker_untrack(tracker, handle);
775 if (ACTIVE_COUNT(tracker) >= tracker->capacity) {
776 ret = fd_tracker_suspend_handles(tracker, 1);
777 if (ret) {
778 goto end;
779 }
780 }
781 ret = fs_handle_restore(handle);
782end:
783 fd_tracker_track(tracker, handle);
784 return ret ? ret : handle->fd;
785}
786
787int fs_handle_get_fd(struct fs_handle *handle)
788{
789 int ret;
790
791 /*
792 * TODO This should be optimized as it is a fairly hot path.
793 * The fd-tracker's lock should only be taken when a fs_handle is
794 * restored (slow path). On the fast path (fs_handle is active),
795 * the only effect on the fd_tracker is marking the handle as the
796 * most recently used. Currently, it is done by a call to the
797 * track/untrack helpers, but it should be done atomically.
798 *
799 * Note that the lock's nesting order must still be respected here.
800 * The handle's lock nests inside the tracker's lock.
801 */
802 pthread_mutex_lock(&handle->tracker->lock);
803 pthread_mutex_lock(&handle->lock);
804 assert(!handle->in_use);
805
806 handle->tracker->stats.uses++;
807 if (handle->fd >= 0) {
808 ret = handle->fd;
809 /* Mark as most recently used. */
810 fd_tracker_untrack(handle->tracker, handle);
811 fd_tracker_track(handle->tracker, handle);
812 } else {
813 handle->tracker->stats.misses++;
814 ret = fd_tracker_restore_handle(handle->tracker, handle);
815 if (ret < 0) {
816 handle->tracker->stats.errors++;
817 goto end;
818 }
819 }
820 handle->in_use = true;
821end:
822 pthread_mutex_unlock(&handle->lock);
823 pthread_mutex_unlock(&handle->tracker->lock);
824 return ret;
825}
826
827void fs_handle_put_fd(struct fs_handle *handle)
828{
829 pthread_mutex_lock(&handle->lock);
830 handle->in_use = false;
831 pthread_mutex_unlock(&handle->lock);
832}
833
9d16fc7f
JG
834int fs_handle_unlink(struct fs_handle *handle)
835{
836 int ret;
837
838 pthread_mutex_lock(&handle->tracker->lock);
839 pthread_mutex_lock(&handle->lock);
840 ret = lttng_inode_defer_unlink(handle->inode);
841 pthread_mutex_unlock(&handle->lock);
842 pthread_mutex_unlock(&handle->tracker->lock);
843 return ret;
844}
845
df038819
JG
846int fs_handle_close(struct fs_handle *handle)
847{
848 int ret = 0;
660a216c 849 const char *path = NULL;
df038819
JG
850
851 if (!handle) {
852 ret = -EINVAL;
853 goto end;
854 }
855
856 pthread_mutex_lock(&handle->tracker->lock);
857 pthread_mutex_lock(&handle->lock);
660a216c
JG
858 if (handle->inode) {
859 path = lttng_inode_get_path(handle->inode);
860 }
df038819
JG
861 fd_tracker_untrack(handle->tracker, handle);
862 if (handle->fd >= 0) {
863 /*
864 * The return value of close() is not propagated as there
865 * isn't much the user can do about it.
866 */
867 if (close(handle->fd)) {
868 PERROR("Failed to close the file descritptor (%d) of fs handle to %s, close() returned",
660a216c 869 handle->fd, path ? path : "Unknown");
df038819
JG
870 }
871 handle->fd = -1;
872 }
874a3441 873 lttng_inode_put(handle->inode);
df038819
JG
874 pthread_mutex_unlock(&handle->lock);
875 pthread_mutex_destroy(&handle->lock);
876 pthread_mutex_unlock(&handle->tracker->lock);
df038819
JG
877 free(handle);
878end:
879 return ret;
880}
This page took 0.094564 seconds and 4 git commands to generate.