1 files changed, 381 insertions, 0 deletions
diff --git a/baobab/src/baobab-scan.c b/baobab/src/baobab-scan.c
new file mode 100644
index 00000000..8c85d859
--- /dev/null
+++ b/baobab/src/baobab-scan.c
@@ -0,0 +1,381 @@
+/*
+ * baobab-scan.c
+ * This file is part of baobab
+ *
+ * Copyright (C) 2005-2006 Fabio Marzocca <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, 
+ * Boston, MA 02110-1301 USA
+ */
+
+
+#include <config.h>
+
+#include <string.h>
+
+#include <glib.h>
+#include <gtk/gtk.h>
+#include <gio/gio.h>
+
+#include "baobab.h"
+#include "baobab-utils.h"
+
+
+/*
+ Hardlinks handling.
+
+ As long as we're optimistic about hardlinks count
+ over the whole system (250 files with st_nlink > 1 here),
+ we keep linear search. If it turns out to be an bottleneck
+ we can switch to an hash table or tree.
+
+ TODO: get real timings about this code. find out the average
+ number of files with st_nlink > 1 on average computer.
+
+ To save memory, we store only { inode, dev } instead of full
+ GFileInfo.
+
+ EDIT: /me stupid. I realize that this code was not called that often
+ 1 call per file with st_nlink > 1. BUT, i'm using pdumpfs to backup
+ my /etc. pdumpfs massively uses hard links. So there are more than
+ 5000 files with st_nlink > 1. I believe this is the worst case.
+*/
+
+typedef struct {
+ guint64 inode;
+ dev_t device;
+} BaobabHardLink;
+
+typedef GArray BaobabHardLinkArray;
+
+static BaobabHardLinkArray *
+baobab_hardlinks_array_create (void)
+{
+ return g_array_new (FALSE, FALSE, sizeof(BaobabHardLink));
+}
+
+static gboolean
+baobab_hardlinks_array_has (BaobabHardLinkArray *a,
+ BaobabHardLink *s)
+{
+ guint i;
+
+ for (i = 0; i < a->len; ++i) {
+ BaobabHardLink *cur = &g_array_index (a, BaobabHardLink, i);
+
+ /*
+ * cur->st_dev == s->st_dev is the common case and may be more
+ * expansive than cur->st_ino == s->st_ino
+ * so keep this order */
+ if (cur->inode == s->inode && cur->device == s->device)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/* return FALSE if the element was already in the array */
+static gboolean
+baobab_hardlinks_array_add (BaobabHardLinkArray *a,
+ GFileInfo *s)
+{
+
+ if (g_file_info_has_attribute (s, G_FILE_ATTRIBUTE_UNIX_INODE) &&
+ g_file_info_has_attribute (s, G_FILE_ATTRIBUTE_UNIX_DEVICE))
+ {
+ BaobabHardLink hl;
+
+ hl.inode = g_file_info_get_attribute_uint64 (s,
+ G_FILE_ATTRIBUTE_UNIX_INODE);
+ hl.device = g_file_info_get_attribute_uint32 (s,
+ G_FILE_ATTRIBUTE_UNIX_DEVICE);
+
+ if (baobab_hardlinks_array_has (a, &hl))
+ return FALSE;
+
+ g_array_append_val (a, hl);
+
+ return TRUE;
+ }
+ else
+ {
+ g_warning ("Could not obtain inode and device for hardlink");
+ }
+
+ return FALSE;
+}
+
+static void
+baobab_hardlinks_array_free (BaobabHardLinkArray *a)
+{
+/* g_print ("HL len was %d\n", a->len); */
+
+ g_array_free (a, TRUE);
+}
+
+#define BLOCK_SIZE 512
+
+struct allsizes {
+ goffset size;
+ goffset alloc_size;
+ gint depth;
+};
+
+static const char *dir_attributes = \
+ G_FILE_ATTRIBUTE_STANDARD_NAME "," \
+ G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," \
+ G_FILE_ATTRIBUTE_STANDARD_TYPE "," \
+ G_FILE_ATTRIBUTE_STANDARD_SIZE "," \
+ G_FILE_ATTRIBUTE_UNIX_BLOCKS "," \
+ G_FILE_ATTRIBUTE_UNIX_NLINK "," \
+ G_FILE_ATTRIBUTE_UNIX_INODE "," \
+ G_FILE_ATTRIBUTE_UNIX_DEVICE "," \
+ G_FILE_ATTRIBUTE_ACCESS_CAN_READ;
+
+
+static gboolean
+is_in_dot_gvfs (GFile *file)
+{
+ static GFile *dot_gvfs_dir = NULL;
+ GFile *parent;
+ gboolean res = FALSE;
+
+ if (dot_gvfs_dir == NULL)
+ {
+ gchar *dot_gvfs;
+
+ dot_gvfs = g_build_filename (g_get_home_dir (), ".gvfs", NULL);
+
+ dot_gvfs_dir = g_file_new_for_path (dot_gvfs);
+
+ g_free (dot_gvfs);
+ }
+
+ parent = g_file_get_parent (file);
+
+ if (parent != NULL)
+ {
+ res = g_file_equal (parent, dot_gvfs_dir);
+ g_object_unref (parent);
+ }
+
+ return res;
+}
+
+static struct allsizes
+loopdir (GFile *file,
+ GFileInfo *info,
+ guint count,
+ BaobabHardLinkArray *hla,
+ gint current_depth)
+{
+ guint64 tempHLsize = 0;
+ gint elements = 0;
+ struct chan_data data;
+ struct allsizes retloop, temp;
+ GFileInfo *temp_info;
+ GFileEnumerator *file_enum;
+ gchar *dir_uri = NULL;
+ gchar *display_name = NULL;
+ gchar *parse_name = NULL;
+ GError *err = NULL;
+
+ count++;
+ retloop.size = 0;
+ retloop.alloc_size = 0;
+ retloop.depth = 0;
+
+ /* Skip the user excluded folders */
+ if (baobab_is_excluded_location (file))
+ goto exit;
+
+ /* Skip the virtual file systems */
+ if (is_virtual_filesystem (file))
+ goto exit;
+
+ /* FIXME: skip dirs in ~/.gvfs. It would be better to have a way
+ * to check if a file is a FUSE mountpoint instead of just
+ * hardcoding .gvfs */
+ if (is_in_dot_gvfs (file))
+ goto exit;
+
+ parse_name = g_file_get_parse_name (file); 
+
+ if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
+ retloop.size = g_file_info_get_size (info);
+
+ if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_BLOCKS))
+ retloop.alloc_size = BLOCK_SIZE * 
+ g_file_info_get_attribute_uint64 (info,
+ G_FILE_ATTRIBUTE_UNIX_BLOCKS);
+
+ if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME))
+ display_name = g_strdup (g_file_info_get_display_name (info));
+ else
+ /* paranoid fallback */
+ display_name = g_filename_display_basename (g_file_info_get_name (info));
+
+ /* load up the file enumerator */
+ file_enum = g_file_enumerate_children (file,
+ dir_attributes,
+ G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
+ NULL,
+ &err);
+
+ if (file_enum == NULL) {
+ if (!g_error_matches (err, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED)) {
+ g_warning ("couldn't get dir enum for dir %s: %s\n",
+ parse_name, err->message);
+ }
+ goto exit;
+ }
+
+ /* All skipped folders (i.e. bad type, excluded, /proc) must be
+ skept *before* this point. Everything passes the prefill-model
+ will be part of the GUI. */
+
+ /* prefill the model */
+ data.size = 1;
+ data.alloc_size = 1;
+ data.depth = count - 1;
+ data.elements = -1;
+ data.display_name = display_name;
+ data.parse_name = parse_name;
+ data.tempHLsize = tempHLsize;
+ baobab_fill_model (&data);
+
+ g_clear_error (&err);
+ while ((temp_info = g_file_enumerator_next_file (file_enum,
+ NULL,
+ &err)) != NULL) {
+ GFileType temp_type = g_file_info_get_file_type (temp_info);
+ if (baobab.STOP_SCANNING) {
+ g_object_unref (temp_info);
+ g_object_unref (file_enum);
+ goto exit;
+ }
+
+ /* is a directory? */
+ if (temp_type == G_FILE_TYPE_DIRECTORY) {
+ GFile *child_dir = g_file_get_child (file, 
+ g_file_info_get_name (temp_info));
+ temp = loopdir (child_dir, temp_info, count, hla, current_depth+1);
+ retloop.size += temp.size;
+ retloop.alloc_size += temp.alloc_size;
+ retloop.depth = ((temp.depth + 1) > retloop.depth) ? temp.depth + 1 : retloop.depth;
+ elements++;
+ g_object_unref (child_dir);
+ }
+
+ /* is it a regular file? */
+ else if (temp_type == G_FILE_TYPE_REGULAR) {
+ 
+ /* check for hard links only on local files */
+ if (g_file_info_has_attribute (temp_info,
+ G_FILE_ATTRIBUTE_UNIX_NLINK) &&
+ g_file_info_get_attribute_uint32 (temp_info,
+ G_FILE_ATTRIBUTE_UNIX_NLINK) > 1) {
+ 
+ if (!baobab_hardlinks_array_add (hla, temp_info)) {
+
+ /* we already acconted for it */
+ tempHLsize += g_file_info_get_size (temp_info);
+ g_object_unref (temp_info);
+ continue;
+ }
+ }
+
+ if (g_file_info_has_attribute (temp_info, G_FILE_ATTRIBUTE_UNIX_BLOCKS)) {
+ retloop.alloc_size += BLOCK_SIZE *
+ g_file_info_get_attribute_uint64 (temp_info,
+ G_FILE_ATTRIBUTE_UNIX_BLOCKS);
+ }
+ retloop.size += g_file_info_get_size (temp_info);
+ elements++;
+ }
+
+ /* ignore other types (symlinks, sockets, devices, etc) */
+
+ g_object_unref (temp_info);
+ }
+
+ /* won't be an error if we've finished normally */
+ if (err != NULL) {
+ g_warning ("error in dir %s: %s\n", 
+ parse_name, err->message);
+ }
+
+ data.display_name = display_name;
+ data.parse_name = parse_name;
+ data.size = retloop.size;
+ data.alloc_size = retloop.alloc_size;
+ data.depth = count - 1;
+ data.elements = elements;
+ data.tempHLsize = tempHLsize;
+ baobab_fill_model (&data);
+ g_object_unref (file_enum);
+
+ exit:
+ g_free (dir_uri);
+ g_free (display_name);
+ g_free (parse_name);
+ if (err)
+ g_error_free (err);
+
+ return retloop;
+}
+
+void
+baobab_scan_execute (GFile *location)
+{
+ BaobabHardLinkArray *hla;
+ GFileInfo *info;
+ GError *err = NULL;
+ GFileType ftype;
+ struct allsizes sizes;
+
+ g_return_if_fail (location != NULL);
+
+ /* NOTE: for the root of the scan we follow symlinks */
+ info = g_file_query_info (location,
+ dir_attributes,
+ G_FILE_QUERY_INFO_NONE,
+ NULL,
+ &err);
+
+ if (info == NULL) {
+ char *parse_name = g_file_get_parse_name (location);
+ g_warning ("couldn't get info for dir %s: %s\n",
+ parse_name, err->message);
+ g_free (parse_name);
+ g_error_free (err);
+
+ return;
+ }
+
+ ftype = g_file_info_get_file_type (info);
+
+ if (ftype == G_FILE_TYPE_DIRECTORY) {
+ hla = baobab_hardlinks_array_create ();
+
+ sizes = loopdir (location, info, 0, hla, 0);
+ baobab.model_max_depth = sizes.depth;
+
+ baobab_hardlinks_array_free (hla);
+ }
+
+ g_object_unref (info);
+}
+