gboolean gsd_should_ignore_unix_mount (GUnixMountEntry *mount) { const char *fs, *device; guint i; /* This is borrowed from GLib and used as a way to determine * which mounts we should ignore by default. GLib doesn't * expose this in a way that allows it to be used for this * purpose */ /* We also ignore network filesystems */ const gchar *ignore_fs[] = { "adfs", "afs", "auto", "autofs", "autofs4", "cgroup", "cifs", "configfs", "cxfs", "debugfs", "devfs", "devpts", "devtmpfs", "ecryptfs", "fdescfs", "fusectl", "gfs", "gfs2", "gpfs", "hugetlbfs", "kernfs", "linprocfs", "linsysfs", "lustre", "lustre_lite", "mfs", "mqueue", "ncpfs", "nfs", "nfs4", "nfsd", "nullfs", "ocfs2", "overlay", "proc", "procfs", "pstore", "ptyfs", "rootfs", "rpc_pipefs", "securityfs", "selinuxfs", "smbfs", "sysfs", "tmpfs", "usbfs", "zfs", NULL }; const gchar *ignore_devices[] = { "none", "sunrpc", "devpts", "nfsd", "/dev/loop", "/dev/vn", NULL }; fs = g_unix_mount_get_fs_type (mount); device = g_unix_mount_get_device_path (mount); for (i = 0; ignore_fs[i] != NULL; i++) if (g_str_equal (ignore_fs[i], fs)) return TRUE; for (i = 0; ignore_devices[i] != NULL; i++) if (g_str_equal (ignore_devices[i], device)) return TRUE; return FALSE; }
static gchar * mount_guess_content_type (GMount *mount, gboolean *is_optical, gboolean *is_multimedia, gboolean *is_blank) { gchar *content_type = NULL; gchar **guess_type; *is_optical = FALSE; *is_multimedia = FALSE; *is_blank = FALSE; /* This function has 2 purposes: * * 1. Detect if we are using optical media * 2. Detect if we are video or music, we can't index those types * * We try to determine the content type because we don't want * to store Volume information in Tracker about DVDs and media * which has no real data for us to mine. * * Generally, if is_multimedia is TRUE then we end up ignoring * the media. */ guess_type = g_mount_guess_content_type_sync (mount, TRUE, NULL, NULL); if (guess_type) { gint i = 0; while (!content_type && guess_type[i]) { if (!g_strcmp0 (guess_type[i], "x-content/image-picturecd")) { /* Images */ content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/video-bluray") || !g_strcmp0 (guess_type[i], "x-content/video-dvd") || !g_strcmp0 (guess_type[i], "x-content/video-hddvd") || !g_strcmp0 (guess_type[i], "x-content/video-svcd") || !g_strcmp0 (guess_type[i], "x-content/video-vcd")) { /* Videos */ *is_multimedia = TRUE; content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/audio-cdda") || !g_strcmp0 (guess_type[i], "x-content/audio-dvd") || !g_strcmp0 (guess_type[i], "x-content/audio-player")) { /* Audios */ *is_multimedia = TRUE; content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/blank-bd") || !g_strcmp0 (guess_type[i], "x-content/blank-cd") || !g_strcmp0 (guess_type[i], "x-content/blank-dvd") || !g_strcmp0 (guess_type[i], "x-content/blank-hddvd")) { /* Blank */ *is_blank = TRUE; content_type = g_strdup (guess_type[i]); } else if (!g_strcmp0 (guess_type[i], "x-content/software") || !g_strcmp0 (guess_type[i], "x-content/unix-software") || !g_strcmp0 (guess_type[i], "x-content/win32-software")) { /* NOTE: This one is a guess, can we * have this content type on * none-optical mount points? */ content_type = g_strdup (guess_type[i]); } else { /* else, keep on with the next guess, if any */ i++; } } /* If we didn't have an exact match on possible guessed content types, * then use the first one returned (best guess always first) if any */ if (!content_type && guess_type[0]) { content_type = g_strdup (guess_type[0]); } g_strfreev (guess_type); } if (content_type) { if (strstr (content_type, "vcd") || strstr (content_type, "cdda") || strstr (content_type, "dvd") || strstr (content_type, "bluray")) { *is_optical = TRUE; } } else { GUnixMountEntry *entry; gchar *mount_path; GFile *mount_root; /* No content type was guessed, try to find out * at least whether it's an optical media or not */ mount_root = g_mount_get_root (mount); mount_path = g_file_get_path (mount_root); /* FIXME: Try to assume we have a unix mount :( * EEK, once in a while, I have to write crack, oh well */ if (mount_path && (entry = g_unix_mount_at (mount_path, NULL)) != NULL) { const gchar *filesystem_type; gchar *device_path = NULL; GVolume *volume; volume = g_mount_get_volume (mount); filesystem_type = g_unix_mount_get_fs_type (entry); g_debug (" Using filesystem type:'%s'", filesystem_type); /* Volume may be NULL */ if (volume) { device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_debug (" Using device path:'%s'", device_path); g_object_unref (volume); } /* NOTE: This code was taken from guess_mount_type() * in GIO's gunixmounts.c and adapted purely for * guessing optical media. We don't use the guessing * code for other types such as MEMSTICKS, ZIPs, * IPODs, etc. * * This code may need updating over time since it is * very situational depending on how distributions * mount their devices and how devices are named in * /dev. */ if (strcmp (filesystem_type, "udf") == 0 || strcmp (filesystem_type, "iso9660") == 0 || strcmp (filesystem_type, "cd9660") == 0 || (device_path && (g_str_has_prefix (device_path, "/dev/cdrom") || g_str_has_prefix (device_path, "/dev/acd") || g_str_has_prefix (device_path, "/dev/cd")))) { *is_optical = TRUE; } else if (device_path && g_str_has_prefix (device_path, "/vol/")) { const gchar *name; name = mount_path + strlen ("/"); if (g_str_has_prefix (name, "cdrom")) { *is_optical = TRUE; } } else { gchar *basename = g_path_get_basename (mount_path); if (g_str_has_prefix (basename, "cdr") || g_str_has_prefix (basename, "cdwriter") || g_str_has_prefix (basename, "burn") || g_str_has_prefix (basename, "dvdr")) { *is_optical = TRUE; } g_free (basename); } g_free (device_path); g_free (mount_path); g_unix_mount_free (entry); } else { g_debug (" No GUnixMountEntry found, needed for detecting if optical media... :("); g_free (mount_path); } g_object_unref (mount_root); } return content_type; }
static VALUE unixmount_get_fs_type(VALUE self) { return CSTR2RVAL(g_unix_mount_get_fs_type(_SELF(self))); }
static gboolean ldsm_mount_should_ignore (GUnixMountEntry *mount) { const gchar *fs, *device, *path; path = g_unix_mount_get_mount_path (mount); if (ldsm_mount_is_user_ignore (path)) return TRUE; /* This is borrowed from GLib and used as a way to determine * which mounts we should ignore by default. GLib doesn't * expose this in a way that allows it to be used for this * purpose */ /* We also ignore network filesystems */ const gchar *ignore_fs[] = { "adfs", "afs", "auto", "autofs", "autofs4", "cifs", "cxfs", "devfs", "devpts", "ecryptfs", "fdescfs", "gfs", "gfs2", "kernfs", "linprocfs", "linsysfs", "lustre", "lustre_lite", "ncpfs", "nfs", "nfs4", "nfsd", "ocfs2", "proc", "procfs", "ptyfs", "rpc_pipefs", "selinuxfs", "smbfs", "sysfs", "tmpfs", "usbfs", "zfs", NULL }; const gchar *ignore_devices[] = { "none", "sunrpc", "devpts", "nfsd", "/dev/loop", "/dev/vn", NULL }; fs = g_unix_mount_get_fs_type (mount); device = g_unix_mount_get_device_path (mount); if (is_in (fs, ignore_fs)) return TRUE; if (is_in (device, ignore_devices)) return TRUE; return FALSE; }
static RmMountEntries *rm_mount_list_open(RmMountTable *table) { RmMountEntries *self = g_slice_new(RmMountEntries); self->mnt_entries = g_unix_mounts_get(NULL); self->entries = NULL; self->current = NULL; for(GList *iter = self->mnt_entries; iter; iter = iter->next) { RmMountEntry *wrap_entry = g_slice_new(RmMountEntry); GUnixMountEntry *entry = iter->data; wrap_entry->fsname = g_strdup(g_unix_mount_get_device_path(entry)); wrap_entry->dir = g_strdup(g_unix_mount_get_mount_path(entry)); wrap_entry->type = g_strdup(g_unix_mount_get_fs_type(entry)); self->entries = g_list_prepend(self->entries, wrap_entry); } RmMountEntry *wrap_entry = NULL; while((wrap_entry = rm_mount_list_next(self))) { /* bindfs mounts mirror directory trees. * This cannot be detected properly by rmlint since * files in it have the same inode as their unmirrored file, but * a different dev_t. * * Also ignore kernel filesystems. * * So better go and ignore it. */ static struct RmEvilFs { /* fsname as show by `mount` */ const char *name; /* Wether to warn about the exclusion on this */ bool unusual; } evilfs_types[] = {{"bindfs", 1}, {"nullfs", 1}, /* Ignore the usual linux file system spam */ {"proc", 0}, {"cgroup", 0}, {"configfs", 0}, {"sys", 0}, {"devtmpfs", 0}, {"debugfs", 0}, {NULL, 0}}; /* btrfs and ocfs2 filesystems support reflinks for deduplication */ static const char *reflinkfs_types[] = {"btrfs", "ocfs2", NULL}; const struct RmEvilFs *evilfs_found = NULL; for(int i = 0; evilfs_types[i].name && !evilfs_found; ++i) { if(strcmp(evilfs_types[i].name, wrap_entry->type) == 0) { evilfs_found = &evilfs_types[i]; } } const char *reflinkfs_found = NULL; for(int i = 0; reflinkfs_types[i] && !reflinkfs_found; ++i) { if(strcmp(reflinkfs_types[i], wrap_entry->type) == 0) { reflinkfs_found = reflinkfs_types[i]; break; } } if(evilfs_found != NULL) { RmStat dir_stat; rm_sys_stat(wrap_entry->dir, &dir_stat); g_hash_table_insert(table->evilfs_table, GUINT_TO_POINTER(dir_stat.st_dev), GUINT_TO_POINTER(1)); GLogLevelFlags log_level = G_LOG_LEVEL_DEBUG; if(evilfs_found->unusual) { log_level = G_LOG_LEVEL_WARNING; rm_log_warning_prefix(); } else { rm_log_debug_prefix(); } g_log("rmlint", log_level, _("`%s` mount detected at %s (#%u); Ignoring all files in it.\n"), evilfs_found->name, wrap_entry->dir, (unsigned)dir_stat.st_dev); } rm_log_debug_line("Filesystem %s: %s", wrap_entry->dir, (reflinkfs_found) ? "reflink" : "normal"); if(reflinkfs_found != NULL) { RmStat dir_stat; rm_sys_stat(wrap_entry->dir, &dir_stat); g_hash_table_insert(table->reflinkfs_table, GUINT_TO_POINTER(dir_stat.st_dev), (gpointer)reflinkfs_found); } } return self; }