![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[first]](../icons/first.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 Virtual File System garbage collection code
3
4 Copyright (C) 2003-2024
5 Free Software Foundation, Inc.
6
7 Written by:
8 Miguel de Icaza, 1995
9 Jakub Jelinek, 1995
10 Pavel Machek, 1998
11 Pavel Roskin, 2003
12
13 This file is part of the Midnight Commander.
14
15 The Midnight Commander is free software: you can redistribute it
16 and/or modify it under the terms of the GNU General Public License as
17 published by the Free Software Foundation, either version 3 of the License,
18 or (at your option) any later version.
19
20 The Midnight Commander is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program. If not, see <http://www.gnu.org/licenses/>.
27 */
28
29 /**
30 * \file
31 * \brief Source: Virtual File System: garbage collection code
32 * \author Miguel de Icaza
33 * \author Jakub Jelinek
34 * \author Pavel Machek
35 * \author Pavel Roskin
36 * \date 1995, 1998, 2003
37 */
38
39
40 #include <config.h>
41
42 #include <stdlib.h>
43
44 #include "lib/global.h"
45 #include "lib/event.h"
46 #include "lib/util.h" /* MC_PTR_FREE */
47
48 #include "vfs.h"
49 #include "utilvfs.h"
50
51 #include "gc.h"
52
53 /*
54 * The garbage collection mechanism is based on "stamps".
55 *
56 * A stamp is a record that says "I'm a filesystem which is no longer in
57 * use. Free me when you get a chance."
58 *
59 * This file contains a set of functions used for managing this stamp. You
60 * should use them when you write your own filesystem. Here are some rules
61 * of thumb:
62 *
63 * (1) When the last open file in your filesystem gets closed, conditionally
64 * create a stamp. You do this with vfs_stamp_create(). (The meaning
65 * of "conditionally" is explained below.)
66 *
67 * (2) When a file in your filesystem is opened, delete the stamp. You do
68 * this with vfs_rmstamp().
69 *
70 * (3) When a path inside your filesystem is invoked, call vfs_stamp() to
71 * postpone the free'ing of your filesystem a bit. (This simply updates
72 * a timestamp variable inside the stamp.)
73 *
74 * Additionally, when a user navigates to a new directory in a panel (or a
75 * programmer uses mc_chdir()), a stamp is conditionally created for the
76 * previous directory's filesystem. This ensures that that filesystem is
77 * free'ed. (see: _do_panel_cd() -> vfs_release_path(); mc_chdir()).
78 *
79 * We've spoken here of "conditionally creating" a stamp. What we mean is
80 * that vfs_stamp_create() is to be used: this function creates a stamp
81 * only if no directories are open (aka "active") in your filesystem. (If
82 * there _are_ directories open, it means that the filesystem is in use, in
83 * which case we don't want to free it.)
84 */
85
86 /*** global variables ****************************************************************************/
87
88 int vfs_timeout = 60; /* VFS timeout in seconds */
89
90 /*** file scope macro definitions ****************************************************************/
91
92 #define VFS_STAMPING(a) ((struct vfs_stamping *)(a))
93
94 /*** file scope type declarations ****************************************************************/
95
96 struct vfs_stamping
97 {
98 struct vfs_class *v;
99 vfsid id;
100 gint64 time;
101 };
102
103 /*** forward declarations (file scope functions) *************************************************/
104
105 /*** file scope variables ************************************************************************/
106
107 static GSList *stamps = NULL;
108
109 /* --------------------------------------------------------------------------------------------- */
110 /*** file scope functions ************************************************************************/
111 /* --------------------------------------------------------------------------------------------- */
112
113 static gint
114 vfs_stamp_compare (gconstpointer a, gconstpointer b)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
115 {
116 const struct vfs_stamping *vsa = (const struct vfs_stamping *) a;
117 const struct vfs_stamping *vsb = (const struct vfs_stamping *) b;
118
119 return (vsa == NULL || vsb == NULL || (vsa->v == vsb->v && vsa->id == vsb->id)) ? 0 : 1;
120 }
121
122 /* --------------------------------------------------------------------------------------------- */
123
124 static void
125 vfs_addstamp (struct vfs_class *v, vfsid id)
/* ![[previous]](../icons/left.png)
*/
126 {
127 if ((v->flags & VFSF_LOCAL) == 0 && id != NULL && !vfs_stamp (v, id))
128 {
129 struct vfs_stamping *stamp;
130
131 stamp = g_new (struct vfs_stamping, 1);
132 stamp->v = v;
133 stamp->id = id;
134 stamp->time = g_get_monotonic_time ();
135
136 stamps = g_slist_append (stamps, stamp);
137 }
138 }
139
140 /* --------------------------------------------------------------------------------------------- */
141 /*** public functions ****************************************************************************/
142 /* --------------------------------------------------------------------------------------------- */
143
144 gboolean
145 vfs_stamp (struct vfs_class *v, vfsid id)
/* */
146 {
147 struct vfs_stamping what = {
148 .v = v,
149 .id = id
150 };
151 GSList *stamp;
152 gboolean ret = FALSE;
153
154 stamp = g_slist_find_custom (stamps, &what, vfs_stamp_compare);
155 if (stamp != NULL && stamp->data != NULL)
156 {
157 VFS_STAMPING (stamp->data)->time = g_get_monotonic_time ();
158 ret = TRUE;
159 }
160
161 return ret;
162 }
163
164 /* --------------------------------------------------------------------------------------------- */
165
166 void
167 vfs_rmstamp (struct vfs_class *v, vfsid id)
/* */
168 {
169 struct vfs_stamping what = {
170 .v = v,
171 .id = id
172 };
173 GSList *stamp;
174
175 stamp = g_slist_find_custom (stamps, &what, vfs_stamp_compare);
176 if (stamp != NULL)
177 {
178 g_free (stamp->data);
179 stamps = g_slist_delete_link (stamps, stamp);
180 }
181 }
182
183 /* --------------------------------------------------------------------------------------------- */
184
185 void
186 vfs_stamp_path (const vfs_path_t *vpath)
/* */
187 {
188 vfsid id;
189 struct vfs_class *me;
190
191 me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
192 id = vfs_getid (vpath);
193 vfs_addstamp (me, id);
194 }
195
196 /* --------------------------------------------------------------------------------------------- */
197 /**
198 * Create a new timestamp item by VFS class and VFS id.
199 */
200
201 void
202 vfs_stamp_create (struct vfs_class *vclass, vfsid id)
/* */
203 {
204 vfsid nvfsid;
205
206 ev_vfs_stamp_create_t event_data = { vclass, id, FALSE };
207 const vfs_path_t *vpath;
208 struct vfs_class *me;
209
210 /* There are three directories we have to take care of: current_dir,
211 current_panel->cwd and other_panel->cwd. Although most of the time either
212 current_dir and current_panel->cwd or current_dir and other_panel->cwd are the
213 same, it's possible that all three are different -- Norbert */
214
215 if (!mc_event_present (MCEVENT_GROUP_CORE, "vfs_timestamp"))
216 return;
217
218 vpath = vfs_get_raw_current_dir ();
219 me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
220
221 nvfsid = vfs_getid (vpath);
222 vfs_rmstamp (me, nvfsid);
223
224 if (!(id == NULL || (me == vclass && nvfsid == id)))
225 {
226 mc_event_raise (MCEVENT_GROUP_CORE, "vfs_timestamp", (gpointer) & event_data);
227
228 if (!event_data.ret && vclass != NULL && vclass->nothingisopen != NULL
229 && vclass->nothingisopen (id))
230 vfs_addstamp (vclass, id);
231 }
232 }
233
234 /* --------------------------------------------------------------------------------------------- */
235 /** This is called from timeout handler with now = FALSE,
236 or can be called with now = TRUE to force freeing all filesystems */
237
238 void
239 vfs_expire (gboolean now)
/* */
240 {
241 static gboolean locked = FALSE;
242 gint64 curr_time, exp_time;
243 GSList *stamp;
244
245 /* Avoid recursive invocation, e.g. when one of the free functions
246 calls message */
247 if (locked)
248 return;
249 locked = TRUE;
250
251 curr_time = g_get_monotonic_time ();
252 exp_time = curr_time - vfs_timeout * G_USEC_PER_SEC;
253
254 if (now)
255 {
256 /* reverse list to free nested VFSes at first */
257 stamps = g_slist_reverse (stamps);
258 }
259
260 /* NULLize stamps that point to expired VFS */
261 for (stamp = stamps; stamp != NULL; stamp = g_slist_next (stamp))
262 {
263 struct vfs_stamping *stamping = VFS_STAMPING (stamp->data);
264
265 if (now)
266 {
267 /* free VFS forced */
268 if (stamping->v->free != NULL)
269 stamping->v->free (stamping->id);
270 MC_PTR_FREE (stamp->data);
271 }
272 else if (stamping->time <= exp_time)
273 {
274 /* update timestamp of VFS that is in use, or free unused VFS */
275 if (stamping->v->nothingisopen != NULL && !stamping->v->nothingisopen (stamping->id))
276 stamping->time = curr_time;
277 else
278 {
279 if (stamping->v->free != NULL)
280 stamping->v->free (stamping->id);
281 MC_PTR_FREE (stamp->data);
282 }
283 }
284 }
285
286 /* then remove NULLized stamps */
287 stamps = g_slist_remove_all (stamps, NULL);
288
289 locked = FALSE;
290 }
291
292 /* --------------------------------------------------------------------------------------------- */
293 /*
294 * Return the number of seconds remaining to the vfs timeout.
295 * FIXME: The code should be improved to actually return the number of
296 * seconds until the next item times out.
297 */
298
299 int
300 vfs_timeouts (void)
/* */
301 {
302 return stamps != NULL ? 10 : 0;
303 }
304
305 /* --------------------------------------------------------------------------------------------- */
306
307 void
308 vfs_timeout_handler (void)
/* */
309 {
310 vfs_expire (FALSE);
311 }
312
313 /* --------------------------------------------------------------------------------------------- */
314
315 void
316 vfs_release_path (const vfs_path_t *vpath)
/* */
317 {
318 vfsid id;
319 struct vfs_class *me;
320
321 me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
322 id = vfs_getid (vpath);
323 vfs_stamp_create (me, id);
324 }
325
326 /* --------------------------------------------------------------------------------------------- */
327 /* Free all data */
328
329 void
330 vfs_gc_done (void)
/* ![[last]](../icons/n_last.png)
*/
331 {
332 vfs_expire (TRUE);
333 }
334
335 /* --------------------------------------------------------------------------------------------- */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/