lib/vfs/gc.c

   1 /*
   2    Virtual File System garbage collection code
   3
   4    Copyright (C) 2003, 2004, 2005, 2007, 2011
   5    The 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>             /* For atol() */
  43 #include <sys/types.h>
  44 #include <sys/time.h>           /* gettimeofday() */
  45
  46 #include "lib/global.h"
  47 #include "lib/event.h"
  48
  49 #include "vfs.h"
  50 #include "utilvfs.h"
  51
  52 #include "gc.h"
  53
  54 /*** global variables ****************************************************************************/
  55
  56 int vfs_timeout = 60;           /* VFS timeout in seconds */
  57
  58 /*** file scope macro definitions ****************************************************************/
  59
  60 /*** file scope type declarations ****************************************************************/
  61
  62 /*** file scope variables ************************************************************************/
  63
  64 static struct vfs_stamping *stamps;
  65
  66 /*** file scope functions ************************************************************************/
  67 /* --------------------------------------------------------------------------------------------- */
  68
  69 static void
  70 vfs_addstamp (struct vfs_class *v, vfsid id)
  71 {
  72     if (!(v->flags & VFSF_LOCAL) && id != NULL)
  73     {
  74         struct vfs_stamping *stamp;
  75         struct vfs_stamping *last_stamp = NULL;
  76
  77         for (stamp = stamps; stamp != NULL; stamp = stamp->next)
  78         {
  79             if (stamp->v == v && stamp->id == id)
  80             {
  81                 gettimeofday (&(stamp->time), NULL);
  82                 return;
  83             }
  84             last_stamp = stamp;
  85         }
  86         stamp = g_new (struct vfs_stamping, 1);
  87         stamp->v = v;
  88         stamp->id = id;
  89
  90         gettimeofday (&(stamp->time), NULL);
  91         stamp->next = 0;
  92
  93         if (stamps)
  94         {
  95             /* Add to the end */
  96             last_stamp->next = stamp;
  97         }
  98         else
  99         {
 100             /* Add first element */
 101             stamps = stamp;
 102         }
 103     }
 104 }
 105
 106 /* --------------------------------------------------------------------------------------------- */
 107 /** Compare two timeval structures.  Return 0 is t1 is less than t2. */
 108
 109 static inline int
 110 timeoutcmp (struct timeval *t1, struct timeval *t2)
 111 {
 112     return ((t1->tv_sec < t2->tv_sec)
 113             || ((t1->tv_sec == t2->tv_sec) && (t1->tv_usec <= t2->tv_usec)));
 114 }
 115
 116 /* --------------------------------------------------------------------------------------------- */
 117 /*** public functions ****************************************************************************/
 118 /* --------------------------------------------------------------------------------------------- */
 119
 120 void
 121 vfs_stamp (struct vfs_class *v, vfsid id)
 122 {
 123     struct vfs_stamping *stamp;
 124
 125     for (stamp = stamps; stamp != NULL; stamp = stamp->next)
 126         if (stamp->v == v && stamp->id == id)
 127         {
 128             gettimeofday (&(stamp->time), NULL);
 129             return;
 130         }
 131 }
 132
 133 /* --------------------------------------------------------------------------------------------- */
 134
 135 void
 136 vfs_rmstamp (struct vfs_class *v, vfsid id)
 137 {
 138     struct vfs_stamping *stamp, *st1;
 139
 140     for (stamp = stamps, st1 = NULL; stamp != NULL; st1 = stamp, stamp = stamp->next)
 141         if (stamp->v == v && stamp->id == id)
 142         {
 143             if (st1 == NULL)
 144             {
 145                 stamps = stamp->next;
 146             }
 147             else
 148             {
 149                 st1->next = stamp->next;
 150             }
 151             g_free (stamp);
 152
 153             return;
 154         }
 155 }
 156
 157 /* --------------------------------------------------------------------------------------------- */
 158
 159 void
 160 vfs_stamp_path (const char *path)
 161 {
 162     vfsid id;
 163     vfs_path_t *vpath;
 164     const vfs_path_element_t *path_element;
 165
 166     vpath = vfs_path_from_str (path);
 167     path_element = vfs_path_get_by_index (vpath, -1);
 168
 169     id = vfs_getid (vpath);
 170     vfs_addstamp (path_element->class, id);
 171     vfs_path_free (vpath);
 172 }
 173
 174 /* --------------------------------------------------------------------------------------------- */
 175 /**
 176  * Create a new timestamp item by VFS class and VFS id.
 177  */
 178
 179 void
 180 vfs_stamp_create (struct vfs_class *vclass, vfsid id)
 181 {
 182     vfsid nvfsid;
 183
 184     ev_vfs_stamp_create_t event_data = { vclass, id, FALSE };
 185     vfs_path_t *vpath;
 186     const vfs_path_element_t *path_element;
 187
 188     /* There are three directories we have to take care of: current_dir,
 189        current_panel->cwd and other_panel->cwd. Athough most of the time either
 190        current_dir and current_panel->cwd or current_dir and other_panel->cwd are the
 191        same, it's possible that all three are different -- Norbert */
 192
 193     if (!mc_event_present (MCEVENT_GROUP_CORE, "vfs_timestamp"))
 194         return;
 195
 196     vpath = vfs_get_raw_current_dir ();
 197     path_element = vfs_path_get_by_index (vpath, -1);
 198
 199     nvfsid = vfs_getid (vpath);
 200     vfs_rmstamp (path_element->class, nvfsid);
 201
 202     if (!(id == NULL || (path_element->class == vclass && nvfsid == id)))
 203     {
 204         mc_event_raise (MCEVENT_GROUP_CORE, "vfs_timestamp", (gpointer) & event_data);
 205
 206         if (!event_data.ret && vclass != NULL && vclass->nothingisopen != NULL
 207             && vclass->nothingisopen (id) != 0)
 208             vfs_addstamp (vclass, id);
 209     }
 210 }
 211
 212 /* --------------------------------------------------------------------------------------------- */
 213 /** This is called from timeout handler with now = 0, or can be called
 214    with now = 1 to force freeing all filesystems that are not in use */
 215
 216 void
 217 vfs_expire (int now)
 218 {
 219     static int locked = 0;
 220     struct timeval lc_time;
 221     struct vfs_stamping *stamp, *st;
 222
 223     /* Avoid recursive invocation, e.g. when one of the free functions
 224        calls message */
 225     if (locked)
 226         return;
 227     locked = 1;
 228
 229     gettimeofday (&lc_time, NULL);
 230     lc_time.tv_sec -= vfs_timeout;
 231
 232     for (stamp = stamps; stamp != NULL;)
 233     {
 234         if (now || (timeoutcmp (&stamp->time, &lc_time)))
 235         {
 236             st = stamp->next;
 237             if (stamp->v->free)
 238                 (*stamp->v->free) (stamp->id);
 239             vfs_rmstamp (stamp->v, stamp->id);
 240             stamp = st;
 241         }
 242         else
 243             stamp = stamp->next;
 244     }
 245     locked = 0;
 246 }
 247
 248 /* --------------------------------------------------------------------------------------------- */
 249 /*
 250  * Return the number of seconds remaining to the vfs timeout.
 251  * FIXME: The code should be improved to actually return the number of
 252  * seconds until the next item times out.
 253  */
 254
 255 int
 256 vfs_timeouts ()
 257 {
 258     return stamps ? 10 : 0;
 259 }
 260
 261 /* --------------------------------------------------------------------------------------------- */
 262
 263 void
 264 vfs_timeout_handler (void)
 265 {
 266     vfs_expire (0);
 267 }
 268
 269 /* --------------------------------------------------------------------------------------------- */
 270
 271 void
 272 vfs_release_path (const char *dir)
 273 {
 274     vfs_path_t *vpath;
 275     const vfs_path_element_t *path_element;
 276
 277     vpath = vfs_path_from_str (dir);
 278     path_element = vfs_path_get_by_index (vpath, -1);
 279
 280     vfs_stamp_create (path_element->class, vfs_getid (vpath));
 281     vfs_path_free (vpath);
 282 }
 283
 284 /* --------------------------------------------------------------------------------------------- */
 285 /* Free all data */
 286
 287 void
 288 vfs_gc_done (void)
 289 {
 290     struct vfs_stamping *stamp, *st;
 291
 292     for (stamp = stamps, stamps = 0; stamp != NULL;)
 293     {
 294         if (stamp->v->free)
 295             (*stamp->v->free) (stamp->id);
 296         st = stamp->next;
 297         g_free (stamp);
 298         stamp = st;
 299     }
 300
 301     if (stamps)
 302         vfs_rmstamp (stamps->v, stamps->id);
 303 }
 304
 305 /* --------------------------------------------------------------------------------------------- */