1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/*
* Copyright (C) 2020 Paul Cercueil <paul@crapouillou.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
#include "blockcache.h"
#include "debug.h"
#include "lightrec-private.h"
#include "memmanager.h"
#include "slist.h"
#include "reaper.h"
#include <errno.h>
#include <pthread.h>
#include <stdbool.h>
struct reaper_elm {
reap_func_t func;
void *data;
struct slist_elm slist;
};
struct reaper {
struct lightrec_state *state;
pthread_mutex_t mutex;
struct slist_elm reap_list;
};
struct reaper *lightrec_reaper_init(struct lightrec_state *state)
{
struct reaper *reaper;
int ret;
reaper = lightrec_malloc(state, MEM_FOR_LIGHTREC, sizeof(*reaper));
if (!reaper) {
pr_err("Cannot create reaper: Out of memory\n");
return NULL;
}
reaper->state = state;
slist_init(&reaper->reap_list);
ret = pthread_mutex_init(&reaper->mutex, NULL);
if (ret) {
pr_err("Cannot init mutex variable: %d\n", ret);
lightrec_free(reaper->state, MEM_FOR_LIGHTREC,
sizeof(*reaper), reaper);
return NULL;
}
return reaper;
}
void lightrec_reaper_destroy(struct reaper *reaper)
{
pthread_mutex_destroy(&reaper->mutex);
lightrec_free(reaper->state, MEM_FOR_LIGHTREC, sizeof(*reaper), reaper);
}
int lightrec_reaper_add(struct reaper *reaper, reap_func_t f, void *data)
{
struct reaper_elm *reaper_elm;
struct slist_elm *elm;
int ret = 0;
pthread_mutex_lock(&reaper->mutex);
for (elm = reaper->reap_list.next; elm; elm = elm->next) {
reaper_elm = container_of(elm, struct reaper_elm, slist);
if (reaper_elm->data == data)
goto out_unlock;
}
reaper_elm = lightrec_malloc(reaper->state, MEM_FOR_LIGHTREC,
sizeof(*reaper_elm));
if (!reaper_elm) {
pr_err("Cannot add reaper entry: Out of memory\n");
ret = -ENOMEM;
goto out_unlock;
}
reaper_elm->func = f;
reaper_elm->data = data;
slist_append(&reaper->reap_list, &reaper_elm->slist);
out_unlock:
pthread_mutex_unlock(&reaper->mutex);
return ret;
}
void lightrec_reaper_reap(struct reaper *reaper)
{
struct reaper_elm *reaper_elm;
struct slist_elm *elm;
pthread_mutex_lock(&reaper->mutex);
while (!!(elm = slist_first(&reaper->reap_list))) {
slist_remove(&reaper->reap_list, elm);
pthread_mutex_unlock(&reaper->mutex);
reaper_elm = container_of(elm, struct reaper_elm, slist);
(*reaper_elm->func)(reaper_elm->data);
lightrec_free(reaper->state, MEM_FOR_LIGHTREC,
sizeof(*reaper_elm), reaper_elm);
pthread_mutex_lock(&reaper->mutex);
}
pthread_mutex_unlock(&reaper->mutex);
}
|
