/*
* Copyright (C) 2014 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Author: Vratislav Podzimek <vpodzime@redhat.com>
*/
#include <glib.h>
#include <unistd.h>
#include <glob.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/loop.h>
#include <blockdev/utils.h>
#include "loop.h"
/**
* SECTION: loop
* @short_description: plugin for operations with loop devices
* @title: Loop
* @include: loop.h
*
* A plugin for operations with loop devices. All sizes passed
* in/out to/from the functions are in bytes.
*/
static GMutex loop_control_lock;
/**
* bd_loop_error_quark: (skip)
*/
GQuark bd_loop_error_quark (void)
{
return g_quark_from_static_string ("g-bd-loop-error-quark");
}
/**
* bd_loop_check_deps:
*
* Returns: whether the plugin's runtime dependencies are satisfied or not
*
* Function checking plugin's runtime dependencies.
*
*/
gboolean bd_loop_check_deps (void) {
/* nothing to check here */
return TRUE;
}
/**
* bd_loop_init:
*
* Initializes the plugin. **This function is called automatically by the
* library's initialization functions.**
*
*/
gboolean bd_loop_init (void) {
/* nothing to do here */
return TRUE;
};
/**
* bd_loop_close:
*
* Cleans up after the plugin. **This function is called automatically by the
* library's functions that unload it.**
*
*/
void bd_loop_close (void) {
/* nothing to do here */
}
#define UNUSED __attribute__((unused))
/**
* bd_loop_is_tech_avail:
* @tech: the queried tech
* @mode: a bit mask of queried modes of operation (#BDLoopTechMode) for @tech
* @error: (out): place to store error (details about why the @tech-@mode combination is not available)
*
* Returns: whether the @tech-@mode combination is available -- supported by the
* plugin implementation and having all the runtime dependencies available
*/
gboolean bd_loop_is_tech_avail (BDLoopTech tech UNUSED, guint64 mode UNUSED, GError **error UNUSED) {
/* all combinations are supported by this implementation of the plugin */
return TRUE;
}
/**
* bd_loop_get_backing_file:
* @dev_name: name of the loop device to get backing file for (e.g. "loop0")
* @error: (out): place to store error (if any)
*
* Returns: (transfer full): path of the device's backing file or %NULL if none
* is found
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_QUERY
*/
gchar* bd_loop_get_backing_file (const gchar *dev_name, GError **error) {
gchar *sys_path = g_strdup_printf ("/sys/class/block/%s/loop/backing_file", dev_name);
gchar *ret = NULL;
gboolean success = FALSE;
if (access (sys_path, R_OK) != 0) {
g_free (sys_path);
return NULL;
}
success = g_file_get_contents (sys_path, &ret, NULL, error);
if (!success) {
/* error is alraedy populated */
g_free (sys_path);
return NULL;
}
g_free (sys_path);
return g_strstrip (ret);
}
/**
* bd_loop_get_loop_name:
* @file: path of the backing file to get loop name for
* @error: (out): place to store error (if any)
*
* Returns: (transfer full): name of the loop device associated with the given
* @file or %NULL if failed to determine
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_QUERY
*/
gchar* bd_loop_get_loop_name (const gchar *file, GError **error __attribute__((unused))) {
glob_t globbuf;
gchar **path_p;
gboolean success = FALSE;
GError *tmp_error = NULL;
gchar *content = NULL;
gboolean found = FALSE;
gchar **parts;
gchar *ret;
if (glob ("/sys/block/loop*/loop/backing_file", GLOB_NOSORT, NULL, &globbuf) != 0) {
return NULL;
}
for (path_p = globbuf.gl_pathv; *path_p && !found; path_p++) {
success = g_file_get_contents (*path_p, &content, NULL, &tmp_error);
if (!success) {
g_clear_error (&tmp_error);
continue;
}
g_strstrip (content);
found = (g_strcmp0 (content, file) == 0);
g_free (content);
}
if (!found) {
globfree (&globbuf);
return NULL;
}
parts = g_strsplit (*(path_p - 1), "/", 5);
ret = g_strdup (parts[3]);
g_strfreev (parts);
globfree (&globbuf);
return ret;
}
/**
* bd_loop_setup:
* @file: file to setup as a loop device
* @offset: offset of the start of the device (in @file)
* @size: maximum size of the device (or 0 to leave unspecified)
* @read_only: whether to setup as read-only (%TRUE) or read-write (%FALSE)
* @part_scan: whether to enforce partition scan on the newly created device or not
* @loop_name: (allow-none) (out): if not %NULL, it is used to store the name of the loop device
* @error: (out): place to store error (if any)
*
* Returns: whether the @file was successfully setup as a loop device or not
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_CREATE
*/
gboolean bd_loop_setup (const gchar *file, guint64 offset, guint64 size, gboolean read_only, gboolean part_scan, const gchar **loop_name, GError **error) {
gint fd = -1;
gboolean ret = FALSE;
/* open as RDWR so that @read_only determines whether the device is
read-only or not */
fd = open (file, O_RDWR);
if (fd < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to open the backing file '%s': %m", file);
return FALSE;
}
ret = bd_loop_setup_from_fd (fd, offset, size, read_only, part_scan, loop_name, error);
close (fd);
return ret;
}
/**
* bd_loop_setup_from_fd:
* @fd: file descriptor for a file to setup as a new loop device
* @offset: offset of the start of the device (in file given by @fd)
* @size: maximum size of the device (or 0 to leave unspecified)
* @read_only: whether to setup as read-only (%TRUE) or read-write (%FALSE)
* @part_scan: whether to enforce partition scan on the newly created device or not
* @loop_name: (allow-none) (out): if not %NULL, it is used to store the name of the loop device
* @error: (out): place to store error (if any)
*
* Returns: whether an new loop device was successfully setup for @fd or not
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_CREATE
*/
gboolean bd_loop_setup_from_fd (gint fd, guint64 offset, guint64 size, gboolean read_only, gboolean part_scan, const gchar **loop_name, GError **error) {
gint loop_control_fd = -1;
gint loop_number = -1;
gchar *loop_device = NULL;
gint loop_fd = -1;
struct loop_info64 li64;
guint64 progress_id = 0;
progress_id = bd_utils_report_started ("Started setting up loop device");
loop_control_fd = open ("/dev/loop-control", O_RDWR);
if (loop_control_fd == -1) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to open the loop-control device: %m");
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
/* XXX: serialize access to loop-control (seems to be required, but it's not
documented anywhere) */
g_mutex_lock (&loop_control_lock);
loop_number = ioctl (loop_control_fd, LOOP_CTL_GET_FREE);
g_mutex_unlock (&loop_control_lock);
close (loop_control_fd);
if (loop_number < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to open the loop-control device: %m");
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
bd_utils_report_progress (progress_id, 33, "Got free loop device");
loop_device = g_strdup_printf ("/dev/loop%d", loop_number);
loop_fd = open (loop_device, read_only ? O_RDONLY : O_RDWR);
if (loop_fd == -1) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to open the %s device: %m", loop_device);
g_free (loop_device);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
memset (&li64, '\0', sizeof (li64));
if (read_only)
li64.lo_flags |= LO_FLAGS_READ_ONLY;
if (part_scan)
li64.lo_flags |= LO_FLAGS_PARTSCAN;
if (offset > 0)
li64.lo_offset = offset;
if (size > 0)
li64.lo_sizelimit = size;
if (ioctl (loop_fd, LOOP_SET_FD, fd) < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_DEVICE,
"Failed to associate the %s device with the file descriptor: %m", loop_device);
g_free (loop_device);
close (loop_fd);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
bd_utils_report_progress (progress_id, 66, "Associated the loop device");
if (ioctl (loop_fd, LOOP_SET_STATUS64, &li64) < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to set status for the %s device: %m", loop_device);
g_free (loop_device);
close (loop_fd);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
if (loop_name)
*loop_name = g_strdup_printf ("loop%d", loop_number);
g_free (loop_device);
close (loop_fd);
bd_utils_report_finished (progress_id, "Completed");
return TRUE;
}
/**
* bd_loop_teardown:
* @loop: path or name of the loop device to tear down
* @error: (out): place to store error (if any)
*
* Returns: whether the @loop device was successfully torn down or not
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_DESTROY
*/
gboolean bd_loop_teardown (const gchar *loop, GError **error) {
gchar *dev_loop = NULL;
gint loop_fd = -1;
guint64 progress_id = 0;
progress_id = bd_utils_report_started ("Started tearing down loop device");
if (!g_str_has_prefix (loop, "/dev/"))
dev_loop = g_strdup_printf ("/dev/%s", loop);
loop_fd = open (dev_loop ? dev_loop : loop, O_RDONLY);
g_free (dev_loop);
if (loop_fd == -1) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to open the %s device: %m", loop);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
if (ioctl (loop_fd, LOOP_CLR_FD) < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to detach the backing file from the %s device: %m", loop);
close (loop_fd);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
close (loop_fd);
bd_utils_report_finished (progress_id, "Completed");
return TRUE;
}
/**
* bd_loop_get_autoclear:
* @loop: path or name of the loop device
* @error: (out): place to store error (if any)
*
* Returns: whether the autoclear flag is set on the @loop device or not (if %FALSE, @error may be set)
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_QUERY
*/
gboolean bd_loop_get_autoclear (const gchar *loop, GError **error) {
gchar *sys_path = NULL;
gboolean success = FALSE;
gchar *contents = NULL;
gboolean ret = FALSE;
gchar *dev_loop = NULL;
gint fd = -1;
struct loop_info64 li64;
/* first try reading the value from /sys which seems to be safer than
potentially stepping on each other's toes with udev during the ioctl() */
if (g_str_has_prefix (loop, "/dev/"))
sys_path = g_strdup_printf ("/sys/class/block/%s/loop/autoclear", loop + 5);
else
sys_path = g_strdup_printf ("/sys/class/block/%s/loop/autoclear", loop);
success = g_file_get_contents (sys_path, &contents, NULL, error);
g_free (sys_path);
if (success) {
g_strstrip (contents);
ret = g_strcmp0 (contents, "1") == 0;
g_free (contents);
return ret;
}
/* else try using the ioctl() (and ignore all previous errors) */
g_clear_error (error);
if (!g_str_has_prefix (loop, "/dev/"))
dev_loop = g_strdup_printf ("/dev/%s", loop);
fd = open (dev_loop ? dev_loop : loop, O_RDONLY);
g_free (dev_loop);
if (fd < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_DEVICE,
"Failed to open device %s: %m", loop);
return FALSE;
}
memset (&li64, 0, sizeof (li64));
if (ioctl (fd, LOOP_GET_STATUS64, &li64) < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to get status of the device %s: %m", loop);
close (fd);
return FALSE;
}
close (fd);
return (li64.lo_flags & LO_FLAGS_AUTOCLEAR) != 0;
}
/**
* bd_loop_set_autoclear:
* @loop: path or name of the loop device
* @autoclear: whether to set or unset the autoclear flag
* @error: (out): place to store error (if any)
*
* Returns: whether the autoclear flag was successfully set on the @loop device or not
*
* Tech category: %BD_LOOP_TECH_LOOP-%BD_LOOP_TECH_MODE_MODIFY
*/
gboolean bd_loop_set_autoclear (const gchar *loop, gboolean autoclear, GError **error) {
gchar *dev_loop = NULL;
gint fd = -1;
struct loop_info64 li64;
guint64 progress_id = 0;
gchar *msg = NULL;
if (!g_str_has_prefix (loop, "/dev/"))
dev_loop = g_strdup_printf ("/dev/%s", loop);
msg = g_strdup_printf ("Started setting up the autoclear flag on the /dev/%s device",
dev_loop ? dev_loop : loop);
progress_id = bd_utils_report_started (msg);
g_free (msg);
fd = open (dev_loop ? dev_loop : loop, O_RDWR);
g_free (dev_loop);
if (fd < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_DEVICE,
"Failed to open device %s: %m", loop);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
memset (&li64, 0, sizeof (li64));
if (ioctl (fd, LOOP_GET_STATUS64, &li64) < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to get status of the device %s: %m", loop);
close (fd);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
if (autoclear)
li64.lo_flags |= LO_FLAGS_AUTOCLEAR;
else
li64.lo_flags &= (~LO_FLAGS_AUTOCLEAR);
if (ioctl (fd, LOOP_SET_STATUS64, &li64) < 0) {
g_set_error (error, BD_LOOP_ERROR, BD_LOOP_ERROR_FAIL,
"Failed to set status of the device %s: %m", loop);
close (fd);
bd_utils_report_finished (progress_id, (*error)->message);
return FALSE;
}
close (fd);
bd_utils_report_finished (progress_id, "Completed");
return TRUE;
}