Git-Mirrors/shufflecake
1
0
Fork 0
mirror of https://codeberg.org/shufflecake/shufflecake-c.git synced 2026-01-06 19:15:38 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Switch to args struct

Browse source
This commit is contained in:
toninov 2025-07-24 20:58:34 +02:00
parent 6206dd4898
commit 5edfda18b0
No known key found for this signature in database
11 changed files with 194 additions and 112 deletions
Download patch file Download diff file Expand all files Collapse all files

31
dm-sflc/src/legacy/device/device.c
View file

@ -56,18 +56,14 @@ static int sflegc_dev_initAndShufflePsiArray(u32 *psi_array, u32 len);
/**
* Creates Device. Returns an ERR_PTR() if unsuccessful.
* Arguments:
* argv[0]: Shufflecake mode: legacy/lite
* argv[1]: Shufflecake-unique device ID
* argv[2]: path to underlying physical device
* argv[3]: volume index within the device
* argv[4]: number of 1 MB slices in the underlying device
* argv[5]: 32-byte encryption key (hex-encoded)
*/
struct sflc_device_base *sflegc_dev_ctr(struct dm_target *ti, int argc, char **argv)
struct sflc_device_base *sflegc_dev_ctr(struct dm_target *ti,
struct sflc_ctor_args_base *args_base)
{
struct sflegc_ctor_args *args = container_of(args_base, struct sflegc_ctor_args, args_base);
sflegc_Device * dev;
u32 tot_slices;
char bdev_name[16];
u32 tot_slices = args->tot_slices;
int err;
int i;
@ -80,26 +76,16 @@ struct sflc_device_base *sflegc_dev_ctr(struct dm_target *ti, int argc, char **a
}
/* Init base part */
err = sflc_dev_base_init(&dev->sd_base, ti, argc, argv);
err = sflc_dev_base_init(&dev->sd_base, ti, args_base);
if (err)
goto bad_base;
dev->sd_base.mode = SFLC_MODE_LEGACY;
dev->sd_base.ops = &sflc_legacy_ops;
/* Parse args */
if (argc != 6) {
pr_err("Wrong argument count");
err = -EINVAL;
goto err_parse;
}
if (sscanf(argv[4], "%u", &tot_slices) != 1) {
pr_err("Could not decode tot_slices\n");
err = -EINVAL;
goto err_parse;
}
/* Set backing real device */
err = dm_get_device(ti, argv[2], dm_table_get_mode(ti->table), &dev->bdev);
format_dev_t(bdev_name, args_base->bdev_devt);
err = dm_get_device(ti, bdev_name, dm_table_get_mode(ti->table), &dev->bdev);
if (err) {
pr_err("Could not dm_get_device: error %d\n", err);
goto err_dm_get_dev;
@ -184,7 +170,6 @@ err_alloc_psi_array:
err_alloc_rmap:
dm_put_device(ti, dev->bdev);
err_dm_get_dev:
err_parse:
sflc_dev_base_exit(&dev->sd_base);
bad_base:
kfree(dev);

3
dm-sflc/src/legacy/device/device.h
View file

@ -145,7 +145,8 @@ struct sflegc_device_s
*****************************************************/
struct sflc_device_base *sflegc_dev_ctr(struct dm_target *ti, int argc, char **argv);
struct sflc_device_base *sflegc_dev_ctr(struct dm_target *ti,
struct sflc_ctor_args_base *args_base);
void sflegc_dev_dtr(struct sflc_device_base *sd_base);
/* Returns false if volume index was already occupied. */

16
dm-sflc/src/legacy/sflc_legacy.h
View file

@ -30,10 +30,26 @@
// For the definition of sflegc_Volume and its functions
#include "legacy/volume/volume.h"
#include "sflc_types.h"
extern struct sflc_mode_ops sflc_legacy_ops;
/* Constructor args */
struct sflegc_ctor_args
{
/* Base args struct */
struct sflc_ctor_args_base args_base;
/* Number of 1 MB slices in the underlying device */
u32 tot_slices;
/* 32-byte encryption key (hex-encoded) */
u8 enckey[SFLEGC_SK_KEY_LEN];
};
int sflegc_init(void);
void sflegc_exit(void);

70
dm-sflc/src/legacy/target.c
View file

@ -46,6 +46,8 @@
* PRIVATE FUNCTIONS PROTOTYPES *
*****************************************************/
static struct sflc_ctor_args_base *sflegc_parse_ctor_args(int argc, char ** argv);
static void sflegc_free_ctor_args(struct sflc_ctor_args_base *args_base);
static int sflegc_tgt_map(struct dm_target *ti, struct bio *bio);
static void sflegc_tgt_ioHints(struct dm_target *ti, struct queue_limits *limits);
static int sflegc_tgt_iterateDevices(struct dm_target *ti, iterate_devices_callout_fn fn,
@ -56,6 +58,8 @@ static int sflegc_tgt_iterateDevices(struct dm_target *ti, iterate_devices_callo
*****************************************************/
struct sflc_mode_ops sflc_legacy_ops = {
.parse_args = sflegc_parse_ctor_args,
.free_args = sflegc_free_ctor_args,
.dev_ctr = sflegc_dev_ctr,
.dev_dtr = sflegc_dev_dtr,
.vol_ctr = sflegc_vol_ctr,
@ -69,6 +73,72 @@ struct sflc_mode_ops sflc_legacy_ops = {
* PRIVATE FUNCTIONS DEFINITIONS *
*****************************************************/
/*
*----------------------------
* Parse arguments
*----------------------------
*/
/* Allocate the args struct and parse the args */
static struct sflc_ctor_args_base *sflegc_parse_ctor_args(int argc, char ** argv)
{
struct sflegc_ctor_args *args;
int err;
/* Allocate outer struct */
args = kzalloc(sizeof(*args), GFP_KERNEL);
if (!args) {
DMERR("Could not allocate sflegc ctor args");
return ERR_PTR(-ENOMEM);
}
if (argc != 6) {
DMERR("Wrong argument count");
err = -EINVAL;
goto bad_parse;
}
/* Tot slices */
if (sscanf(argv[4], "%u", &args->tot_slices) != 1) {
DMERR("Could not decode tot_slices");
err = -EINVAL;
goto bad_parse;
}
/* Decode the encryption key */
if (strlen(argv[5]) != 2 * SFLEGC_SK_KEY_LEN) {
DMERR("Invalid key length");
err = -EINVAL;
goto bad_parse;
}
err = hex2bin(args->enckey, argv[5], SFLEGC_SK_KEY_LEN);
if (err) {
DMERR("Could not decode hexadecimal encryption key");
goto bad_parse;
}
return &args->args_base;
bad_parse:
kfree(args);
return ERR_PTR(err);
}
/* Free the args struct */
static void sflegc_free_ctor_args(struct sflc_ctor_args_base *args_base)
{
struct sflegc_ctor_args *args = container_of(args_base, struct sflegc_ctor_args, args_base);
kfree(args);
}
/*
*----------------------------
* Device mapper target
*----------------------------
*/
/* Callback for every bio submitted to our virtual block device */
static int sflegc_tgt_map(struct dm_target *ti, struct bio *bio)

27
dm-sflc/src/legacy/volume/volume.c
View file

@ -52,9 +52,9 @@
* argv[5]: 32-byte encryption key (hex-encoded)
*/
struct sflc_volume_base *sflegc_vol_ctr(struct sflc_device_base *sd_base,
struct dm_target *ti,
int argc, char **argv)
struct dm_target *ti, struct sflc_ctor_args_base *args_base)
{
struct sflegc_ctor_args *args = container_of(args_base, struct sflegc_ctor_args, args_base);
sflegc_Volume * vol;
sflegc_Device *dev = container_of(sd_base, sflegc_Device, sd_base);
u8 enckey[SFLEGC_SK_KEY_LEN];
@ -69,30 +69,11 @@ struct sflc_volume_base *sflegc_vol_ctr(struct sflc_device_base *sd_base,
}
/* Init base part */
err = sflc_vol_base_init(&vol->sv_base, sd_base, ti, argc, argv);
err = sflc_vol_base_init(&vol->sv_base, sd_base, ti, args_base);
if (err)
goto bad_base;
vol->sv_base.ops = &sflc_legacy_ops;
/* Parse args */
if (argc != 6) {
pr_err("Wrong argument count");
err = -EINVAL;
goto err_parse;
}
/* Decode the encryption key */
if (strlen(argv[5]) != 2 * SFLEGC_SK_KEY_LEN) {
pr_err("Hexadecimal key (length %lu): %s\n", strlen(argv[5]), argv[5]);
err = -EINVAL;
goto err_parse;
}
err = sflegc_str_hexDecode(argv[5], enckey);
if (err) {
pr_err("Could not decode hexadecimal encryption key");
err = -EINVAL;
goto err_parse;
}
/* Sysfs stuff */
err = sflegc_sysfs_add_volume(vol);
if (err) {
@ -109,6 +90,7 @@ struct sflc_volume_base *sflegc_vol_ctr(struct sflc_device_base *sd_base,
vol->dev = dev;
/* Crypto */
memcpy(enckey, args->enckey, SFLEGC_SK_KEY_LEN);
vol->skctx = sflegc_sk_createContext(enckey);
if (IS_ERR(vol->skctx)) {
err = PTR_ERR(vol->skctx);
@ -160,7 +142,6 @@ err_create_skctx:
err_add_to_dev:
sflegc_sysfs_remove_volume(vol);
err_sysfs:
err_parse:
sflc_vol_base_exit(&vol->sv_base);
bad_base:
kfree(vol);

3
dm-sflc/src/legacy/volume/volume.h
View file

@ -127,8 +127,7 @@ struct sflegc_volume_s
*****************************************************/
struct sflc_volume_base *sflegc_vol_ctr(struct sflc_device_base *sd_base,
struct dm_target *ti,
int argc, char **argv);
struct dm_target *ti, struct sflc_ctor_args_base *args_base);
void sflegc_vol_dtr(struct sflc_volume_base *sv_base);
/* Remaps the underlying block device and the sector number */

31
dm-sflc/src/lite/device.c
View file

@ -47,19 +47,13 @@ static void fisheryates_u32(u32 *v, u32 len)
return;
}
/**
* Arguments:
* argv[0]: Shufflecake mode: legacy/lite
* argv[1]: Shufflecake-unique device ID
* argv[2]: path to underlying physical device
* argv[3]: volume index within the device
* argv[4]: number of 1 MB slices in the underlying device
* argv[5]: 64-byte encryption key (hex-encoded)
*/
struct sflc_device_base *sflite_dev_ctr(struct dm_target *ti, int argc, char **argv)
/* Constructor of sflite_device */
struct sflc_device_base *sflite_dev_ctr(struct dm_target *ti,
struct sflc_ctor_args_base *args_base)
{
struct sflite_ctor_args *args = container_of(args_base, struct sflite_ctor_args, args_base);
struct sflite_device *sdev;
u32 tot_slices;
u32 tot_slices = args->tot_slices;
int i;
int err;
@ -70,24 +64,12 @@ struct sflc_device_base *sflite_dev_ctr(struct dm_target *ti, int argc, char **a
}
/* Init base part */
err = sflc_dev_base_init(&sdev->sd_base, ti, argc, argv);
err = sflc_dev_base_init(&sdev->sd_base, ti, args_base);
if (err)
goto bad_base;
sdev->sd_base.mode = SFLC_MODE_LITE;
sdev->sd_base.ops = &sflc_lite_ops;
/* Parse args */
if (argc != 6) {
DMERR("Wrong argument count");
err = -EINVAL;
goto bad_parse;
}
if (sscanf(argv[4], "%u", &tot_slices) != 1) {
DMERR("Could not decode tot_slices");
err = -EINVAL;
goto bad_parse;
}
/* Compute sizes */
sdev->tot_slices = tot_slices;
sdev->nr_free_slices = tot_slices;
@ -176,7 +158,6 @@ bad_bioset:
bad_prmslices:
bitmap_free(sdev->occupation_bitmap);
bad_occ_bitmap:
bad_parse:
sflc_dev_base_exit(&sdev->sd_base);
bad_base:
kfree(sdev);

64
dm-sflc/src/lite/sflc_lite.c
View file

@ -27,10 +27,70 @@
#include "sflite_constants.h"
#include "sflc_lite.h"
// Only to import the definition of struct sflc_volume
// Only to import the definition of struct sflc_volume and the args struct
#include "sflc.h"
/*
*----------------------------
* Parse arguments
*----------------------------
*/
/* Allocate the args struct and parse the args */
static struct sflc_ctor_args_base *sflite_parse_ctor_args(int argc, char ** argv)
{
struct sflite_ctor_args *args;
int err;
/* Allocate outer struct */
args = kzalloc(sizeof(*args), GFP_KERNEL);
if (!args) {
DMERR("Could not allocate sflite ctor args");
return ERR_PTR(-ENOMEM);
}
if (argc != 6) {
DMERR("Wrong argument count");
err = -EINVAL;
goto bad_parse;
}
/* Tot slices */
if (sscanf(argv[4], "%u", &args->tot_slices) != 1) {
DMERR("Could not decode tot_slices");
err = -EINVAL;
goto bad_parse;
}
/* Decode the encryption key */
if (strlen(argv[5]) != 2 * SFLITE_XTS_KEYLEN) {
DMERR("Invalid key length");
err = -EINVAL;
goto bad_parse;
}
err = hex2bin(args->enckey, argv[5], SFLITE_XTS_KEYLEN);
if (err) {
DMERR("Could not decode hexadecimal encryption key");
goto bad_parse;
}
return &args->args_base;
bad_parse:
kfree(args);
return ERR_PTR(err);
}
/* Free the args struct */
static void sflite_free_ctor_args(struct sflc_ctor_args_base *args_base)
{
struct sflite_ctor_args *args = container_of(args_base, struct sflite_ctor_args, args_base);
kfree(args);
}
/*
*----------------------------
* Device mapper target
@ -118,6 +178,8 @@ static int sflite_iterate_devices(struct dm_target *ti, iterate_devices_callout_
struct sflc_mode_ops sflc_lite_ops = {
.parse_args = sflite_parse_ctor_args,
.free_args = sflite_free_ctor_args,
.dev_ctr = sflite_dev_ctr,
.dev_dtr = sflite_dev_dtr,
.vol_ctr = sflite_vol_ctr,

6
dm-sflc/src/lite/sflc_lite.h
View file

@ -45,13 +45,13 @@ int sflite_init(void);
void sflite_exit(void);
/* Device */
struct sflc_device_base *sflite_dev_ctr(struct dm_target *ti, int argc, char **argv);
struct sflc_device_base *sflite_dev_ctr(struct dm_target *ti,
struct sflc_ctor_args_base *args_base);
void sflite_dev_dtr(struct sflc_device_base *sd_base);
/* Volume */
struct sflc_volume_base *sflite_vol_ctr(struct sflc_device_base *sd_base,
struct dm_target *ti,
int argc, char **argv);
struct dm_target *ti, struct sflc_ctor_args_base *args_base);
void sflite_vol_dtr(struct sflc_volume_base *sv_base);
/* Sysfs */

14
dm-sflc/src/lite/sflite_types.h
View file

@ -27,10 +27,10 @@
#include <linux/device-mapper.h>
#include <linux/dm-io.h>
#include <linux/sysfs.h>
#include <linux/rwsem.h>
#include <linux/spinlock.h>
#include <linux/bitmap.h>
#include <crypto/skcipher.h>
#include "sflite_constants.h"
#include "sflc_types.h"
#include "sflc_constants.h"
@ -42,6 +42,18 @@
*----------------------------
*/
struct sflite_ctor_args
{
/* Base args struct */
struct sflc_ctor_args_base args_base;
/* Number of 1 MB slices in the underlying device */
u32 tot_slices;
/* 64-byte encryption key (hex-encoded) */
u8 enckey[SFLITE_XTS_KEYLEN];
};
struct sflite_device
{
/* Base device object */

41
dm-sflc/src/lite/volume.c
View file

@ -26,19 +26,11 @@
#include "sflc.h"
/**
* Arguments:
* argv[0]: Shufflecake mode: legacy/lite
* argv[1]: Shufflecake-unique device ID
* argv[2]: path to underlying physical device
* argv[3]: volume index within the device
* argv[4]: number of 1 MB slices in the underlying device
* argv[5]: 64-byte encryption key (hex-encoded)
*/
/* Constructor of sflite_volume */
struct sflc_volume_base *sflite_vol_ctr(struct sflc_device_base *sd_base,
struct dm_target *ti,
int argc, char **argv)
struct dm_target *ti, struct sflc_ctor_args_base *args_base)
{
struct sflite_ctor_args *args = container_of(args_base, struct sflite_ctor_args, args_base);
struct sflite_volume *svol;
struct sflite_device *sdev = container_of(sd_base, struct sflite_device, sd_base);
int err;
@ -50,33 +42,15 @@ struct sflc_volume_base *sflite_vol_ctr(struct sflc_device_base *sd_base,
}
/* Init base part */
err = sflc_vol_base_init(&svol->sv_base, sd_base, ti, argc, argv);
err = sflc_vol_base_init(&svol->sv_base, sd_base, ti, args_base);
if (err)
goto bad_base;
svol->sv_base.ops = &sflc_lite_ops;
/* Parse arguments */
if (argc != 6) {
DMERR("Wrong argument count");
err = -EINVAL;
goto bad_parse;
}
/* Decode the encryption key */
if (strlen(argv[5]) != 2 * SFLITE_XTS_KEYLEN) {
DMERR("Invalid key length");
err = -EINVAL;
goto bad_parse;
}
err = hex2bin(svol->enckey, argv[5], SFLITE_XTS_KEYLEN);
if (err) {
DMERR("Could not decode hexadecimal encryption key");
err = -EINVAL;
goto bad_parse;
}
/* Assign fields */
svol->sdev = sdev;
svol->ti = ti;
/* Look up underlying block device */
err = dm_get_device(ti, sdev->sd_base.name,
dm_table_get_mode(ti->table), &svol->dm_dev);
if (err) {
@ -91,6 +65,8 @@ struct sflc_volume_base *sflite_vol_ctr(struct sflc_device_base *sd_base,
DMERR("Could not allocate AES-XTS cipher handle; error %d", err);
goto bad_tfm_alloc;
}
/* Copy encryption key from args then set it */
memcpy(svol->enckey, args->enckey, SFLITE_XTS_KEYLEN);
err = crypto_skcipher_setkey(svol->tfm, svol->enckey, SFLITE_XTS_KEYLEN);
if (err) {
DMERR("Could not set key in crypto transform; error %d", err);
@ -163,7 +139,6 @@ bad_tfm_setkey:
bad_tfm_alloc:
dm_put_device(ti, svol->dm_dev);
bad_dm_dev:
bad_parse:
sflc_vol_base_exit(&svol->sv_base);
bad_base:
kfree(svol);