lib/vfs/gc.c

   1 /* Virtual File System garbage collection code
   2    Copyright (C) 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   3
   4    Written by: 1995 Miguel de Icaza
   5    1995 Jakub Jelinek
   6    1998 Pavel Machek
   7    2003 Pavel Roskin
   8
   9    This program is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU Library General Public License
  11    as published by the Free Software Foundation; either version 2 of
  12    the License, or (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU Library General Public License for more details.
  18
  19    You should have received a copy of the GNU Library General Public
  20    License along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  22
  23 /**
  24  * \file
  25  * \brief Source: Virtual File System: garbage collection code
  26  * \author Miguel de Icaza
  27  * \author Jakub Jelinek
  28  * \author Pavel Machek
  29  * \author Pavel Roskin
  30  * \date 1995, 1998, 2003
  31  */
  32
  33
  34 #include <config.h>
  35
  36 #include <stdlib.h>             /* For atol() */
  37 #include <sys/types.h>
  38 #include <sys/time.h>           /* gettimeofday() */
  39
  40 #include "lib/global.h"
  41 #include "lib/event.h"
  42
  43 #include "vfs.h"
  44 #include "utilvfs.h"
  45
  46 #include "gc.h"
  47
  48 /*** global variables ****************************************************************************/
  49
  50 int vfs_timeout = 60;           /* VFS timeout in seconds */
  51
  52 /*** file scope macro definitions ****************************************************************/
  53
  54 /*** file scope type declarations ****************************************************************/
  55
  56 /*** file scope variables ************************************************************************/
  57
  58 static struct vfs_stamping *stamps;
  59
  60 /*** file scope functions ************************************************************************/
  61 /* --------------------------------------------------------------------------------------------- */
  62
  63 static void
  64 vfs_addstamp (struct vfs_class *v, vfsid id)
  65 {
  66     if (!(v->flags & VFSF_LOCAL) && id != NULL)
  67     {
  68         struct vfs_stamping *stamp;
  69         struct vfs_stamping *last_stamp = NULL;
  70
  71         for (stamp = stamps; stamp != NULL; stamp = stamp->next)
  72         {
  73             if (stamp->v == v && stamp->id == id)
  74             {
  75                 gettimeofday (&(stamp->time), NULL);
  76                 return;
  77             }
  78             last_stamp = stamp;
  79         }
  80         stamp = g_new (struct vfs_stamping, 1);
  81         stamp->v = v;
  82         stamp->id = id;
  83
  84         gettimeofday (&(stamp->time), NULL);
  85         stamp->next = 0;
  86
  87         if (stamps)
  88         {
  89             /* Add to the end */
  90             last_stamp->next = stamp;
  91         }
  92         else
  93         {
  94             /* Add first element */
  95             stamps = stamp;
  96         }
  97     }
  98 }
  99
 100 /* --------------------------------------------------------------------------------------------- */
 101 /** Compare two timeval structures.  Return 0 is t1 is less than t2. */
 102
 103 static inline int
 104 timeoutcmp (struct timeval *t1, struct timeval *t2)
 105 {
 106     return ((t1->tv_sec < t2->tv_sec)
 107             || ((t1->tv_sec == t2->tv_sec) && (t1->tv_usec <= t2->tv_usec)));
 108 }
 109
 110 /* --------------------------------------------------------------------------------------------- */
 111 /*** public functions ****************************************************************************/
 112 /* --------------------------------------------------------------------------------------------- */
 113
 114 void
 115 vfs_stamp (struct vfs_class *v, vfsid id)
 116 {
 117     struct vfs_stamping *stamp;
 118
 119     for (stamp = stamps; stamp != NULL; stamp = stamp->next)
 120         if (stamp->v == v && stamp->id == id)
 121         {
 122             gettimeofday (&(stamp->time), NULL);
 123             return;
 124         }
 125 }
 126
 127 /* --------------------------------------------------------------------------------------------- */
 128
 129 void
 130 vfs_rmstamp (struct vfs_class *v, vfsid id)
 131 {
 132     struct vfs_stamping *stamp, *st1;
 133
 134     for (stamp = stamps, st1 = NULL; stamp != NULL; st1 = stamp, stamp = stamp->next)
 135         if (stamp->v == v && stamp->id == id)
 136         {
 137             if (st1 == NULL)
 138             {
 139                 stamps = stamp->next;
 140             }
 141             else
 142             {
 143                 st1->next = stamp->next;
 144             }
 145             g_free (stamp);
 146
 147             return;
 148         }
 149 }
 150
 151 /* --------------------------------------------------------------------------------------------- */
 152
 153 void
 154 vfs_stamp_path (const char *path)
 155 {
 156     vfsid id;
 157     vfs_path_t *vpath;
 158     vfs_path_element_t *path_element;
 159
 160     vpath = vfs_path_from_str (path);
 161     path_element = vfs_path_get_by_index (vpath, vfs_path_length (vpath) - 1);
 162
 163     id = vfs_getid (vpath);
 164     vfs_addstamp (path_element->class, id);
 165     vfs_path_free (vpath);
 166 }
 167
 168 /* --------------------------------------------------------------------------------------------- */
 169 /**
 170  * Create a new timestamp item by VFS class and VFS id.
 171  */
 172
 173 void
 174 vfs_stamp_create (struct vfs_class *vclass, vfsid id)
 175 {
 176     vfsid nvfsid;
 177
 178     ev_vfs_stamp_create_t event_data = { vclass, id, FALSE };
 179     vfs_path_t *vpath;
 180     vfs_path_element_t *path_element;
 181
 182     /* There are three directories we have to take care of: current_dir,
 183        current_panel->cwd and other_panel->cwd. Athough most of the time either
 184        current_dir and current_panel->cwd or current_dir and other_panel->cwd are the
 185        same, it's possible that all three are different -- Norbert */
 186
 187     if (!mc_event_present (MCEVENT_GROUP_CORE, "vfs_timestamp"))
 188         return;
 189
 190     vpath = vfs_path_from_str (vfs_get_current_dir ());
 191     path_element = vfs_path_get_by_index (vpath, vfs_path_length (vpath) - 1);
 192
 193     nvfsid = vfs_getid (vpath);
 194     vfs_rmstamp (path_element->class, nvfsid);
 195
 196     if (!(id == NULL || (path_element->class == vclass && nvfsid == id)))
 197     {
 198         mc_event_raise (MCEVENT_GROUP_CORE, "vfs_timestamp", (gpointer) & event_data);
 199
 200         if (!event_data.ret && vclass != NULL && vclass->nothingisopen != NULL
 201             && vclass->nothingisopen (id) != 0)
 202             vfs_addstamp (vclass, id);
 203     }
 204     vfs_path_free (vpath);
 205 }
 206
 207 /* --------------------------------------------------------------------------------------------- */
 208 /** This is called from timeout handler with now = 0, or can be called
 209    with now = 1 to force freeing all filesystems that are not in use */
 210
 211 void
 212 vfs_expire (int now)
 213 {
 214     static int locked = 0;
 215     struct timeval lc_time;
 216     struct vfs_stamping *stamp, *st;
 217
 218     /* Avoid recursive invocation, e.g. when one of the free functions
 219        calls message */
 220     if (locked)
 221         return;
 222     locked = 1;
 223
 224     gettimeofday (&lc_time, NULL);
 225     lc_time.tv_sec -= vfs_timeout;
 226
 227     for (stamp = stamps; stamp != NULL;)
 228     {
 229         if (now || (timeoutcmp (&stamp->time, &lc_time)))
 230         {
 231             st = stamp->next;
 232             if (stamp->v->free)
 233                 (*stamp->v->free) (stamp->id);
 234             vfs_rmstamp (stamp->v, stamp->id);
 235             stamp = st;
 236         }
 237         else
 238             stamp = stamp->next;
 239     }
 240     locked = 0;
 241 }
 242
 243 /* --------------------------------------------------------------------------------------------- */
 244 /*
 245  * Return the number of seconds remaining to the vfs timeout.
 246  * FIXME: The code should be improved to actually return the number of
 247  * seconds until the next item times out.
 248  */
 249
 250 int
 251 vfs_timeouts ()
 252 {
 253     return stamps ? 10 : 0;
 254 }
 255
 256 /* --------------------------------------------------------------------------------------------- */
 257
 258 void
 259 vfs_timeout_handler (void)
 260 {
 261     vfs_expire (0);
 262 }
 263
 264 /* --------------------------------------------------------------------------------------------- */
 265
 266 void
 267 vfs_release_path (const char *dir)
 268 {
 269     vfs_path_t *vpath;
 270     vfs_path_element_t *path_element;
 271
 272     vpath = vfs_path_from_str (dir);
 273     path_element = vfs_path_get_by_index (vpath, vfs_path_length (vpath) - 1);
 274
 275     vfs_stamp_create (path_element->class, vfs_getid (vpath));
 276 }
 277
 278 /* --------------------------------------------------------------------------------------------- */
 279 /* Free all data */
 280
 281 void
 282 vfs_gc_done (void)
 283 {
 284     struct vfs_stamping *stamp, *st;
 285
 286     for (stamp = stamps, stamps = 0; stamp != NULL;)
 287     {
 288         if (stamp->v->free)
 289             (*stamp->v->free) (stamp->id);
 290         st = stamp->next;
 291         g_free (stamp);
 292         stamp = st;
 293     }
 294
 295     if (stamps)
 296         vfs_rmstamp (stamps->v, stamps->id);
 297 }
 298
 299 /* --------------------------------------------------------------------------------------------- */