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;
}
