lkml.org 
[lkml]   [2026]   [Apr]   [30]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Subject[PATCH V5 1/2] daxctl: Add support for famfs mode
From
Date
From: John Groves <John@Groves.net>

Putting a daxdev in famfs mode means binding it to fsdev_dax.ko
(drivers/dax/fsdev.c). Finding a daxdev bound to fsdev_dax means
it is in famfs mode.

A test for this functionality is added in the next commit.

With devdax, famfs, and system-ram modes, the previous logic that assumed
'not in mode X means in mode Y' needed to get slightly more complicated.

Add explicit mode detection functions:
- daxctl_dev_is_famfs_mode(): check if bound to fsdev_dax driver
- daxctl_dev_is_devdax_mode(): check if bound to device_dax driver
Both delegate to a shared static helper daxctl_dev_bound_to_module() to
avoid duplicating the driver-symlink lookup, as does the pre-existing
daxctl_dev_is_system_ram_capable().

Update mode transition logic in device.c:
- disable_devdax_device(): verify device is actually in devdax mode
- disable_famfs_device(): verify device is actually in famfs mode
- All reconfig_mode_*() functions explicitly check each mode
- Handle unrecognized mode with an error instead of wrong assumption

Update json.c to report fsdev_dax-bound devices as 'famfs' mode. An
unbound device continues to be reported as 'devdax' (the legacy default
when no driver is bound), to preserve existing behavior.

Signed-off-by: John Groves <john@groves.net>
---
daxctl/device.c | 132 ++++++++++++++++++++++++++++++---
daxctl/json.c | 13 +++-
daxctl/lib/libdaxctl-private.h | 2 +
daxctl/lib/libdaxctl.c | 39 +++++++++-
daxctl/lib/libdaxctl.sym | 7 ++
daxctl/libdaxctl.h | 3 +
6 files changed, 181 insertions(+), 15 deletions(-)

diff --git a/daxctl/device.c b/daxctl/device.c
index a4e36b1..003609e 100644
--- a/daxctl/device.c
+++ b/daxctl/device.c
@@ -42,6 +42,7 @@ enum dev_mode {
DAXCTL_DEV_MODE_UNKNOWN,
DAXCTL_DEV_MODE_DEVDAX,
DAXCTL_DEV_MODE_RAM,
+ DAXCTL_DEV_MODE_FAMFS,
};

struct mapping {
@@ -471,6 +472,13 @@ static const char *parse_device_options(int argc, const char **argv,
"--no-online is incompatible with --mode=devdax\n");
rc = -EINVAL;
}
+ } else if (strcmp(param.mode, "famfs") == 0) {
+ reconfig_mode = DAXCTL_DEV_MODE_FAMFS;
+ if (param.no_online) {
+ fprintf(stderr,
+ "--no-online is incompatible with --mode=famfs\n");
+ rc = -EINVAL;
+ }
}
break;
case ACTION_CREATE:
@@ -696,8 +704,42 @@ static int disable_devdax_device(struct daxctl_dev *dev)
int rc;

if (mem) {
- fprintf(stderr, "%s was already in system-ram mode\n",
- devname);
+ fprintf(stderr, "%s is in system-ram mode\n", devname);
+ return 1;
+ }
+ if (daxctl_dev_is_famfs_mode(dev)) {
+ fprintf(stderr, "%s is in famfs mode\n", devname);
+ return 1;
+ }
+ if (!daxctl_dev_is_devdax_mode(dev)) {
+ fprintf(stderr, "%s is not in devdax mode\n", devname);
+ return 1;
+ }
+ rc = daxctl_dev_disable(dev);
+ if (rc) {
+ fprintf(stderr, "%s: disable failed: %s\n",
+ daxctl_dev_get_devname(dev), strerror(-rc));
+ return rc;
+ }
+ return 0;
+}
+
+static int disable_famfs_device(struct daxctl_dev *dev)
+{
+ struct daxctl_memory *mem = daxctl_dev_get_memory(dev);
+ const char *devname = daxctl_dev_get_devname(dev);
+ int rc;
+
+ if (mem) {
+ fprintf(stderr, "%s is in system-ram mode\n", devname);
+ return 1;
+ }
+ if (daxctl_dev_is_devdax_mode(dev)) {
+ fprintf(stderr, "%s is in devdax mode\n", devname);
+ return 1;
+ }
+ if (!daxctl_dev_is_famfs_mode(dev)) {
+ fprintf(stderr, "%s is not in famfs mode\n", devname);
return 1;
}
rc = daxctl_dev_disable(dev);
@@ -711,6 +753,7 @@ static int disable_devdax_device(struct daxctl_dev *dev)

static int reconfig_mode_system_ram(struct daxctl_dev *dev)
{
+ struct daxctl_memory *mem = daxctl_dev_get_memory(dev);
const char *devname = daxctl_dev_get_devname(dev);
int rc, skip_enable = 0;

@@ -724,11 +767,21 @@ static int reconfig_mode_system_ram(struct daxctl_dev *dev)
}

if (daxctl_dev_is_enabled(dev)) {
- rc = disable_devdax_device(dev);
- if (rc < 0)
- return rc;
- if (rc > 0)
+ if (mem) {
+ /* already in system-ram mode */
skip_enable = 1;
+ } else if (daxctl_dev_is_famfs_mode(dev)) {
+ rc = disable_famfs_device(dev);
+ if (rc)
+ return rc;
+ } else if (daxctl_dev_is_devdax_mode(dev)) {
+ rc = disable_devdax_device(dev);
+ if (rc)
+ return rc;
+ } else {
+ fprintf(stderr, "%s: unknown mode\n", devname);
+ return -EINVAL;
+ }
}

if (!skip_enable) {
@@ -750,7 +803,7 @@ static int disable_system_ram_device(struct daxctl_dev *dev)
int rc;

if (!mem) {
- fprintf(stderr, "%s was already in devdax mode\n", devname);
+ fprintf(stderr, "%s is not in system-ram mode\n", devname);
return 1;
}

@@ -786,12 +839,31 @@ static int disable_system_ram_device(struct daxctl_dev *dev)

static int reconfig_mode_devdax(struct daxctl_dev *dev)
{
+ struct daxctl_memory *mem = daxctl_dev_get_memory(dev);
+ const char *devname = daxctl_dev_get_devname(dev);
int rc;

if (daxctl_dev_is_enabled(dev)) {
- rc = disable_system_ram_device(dev);
- if (rc)
- return rc;
+ if (mem) {
+ rc = disable_system_ram_device(dev);
+ if (rc)
+ return rc;
+ } else if (daxctl_dev_is_famfs_mode(dev)) {
+ rc = disable_famfs_device(dev);
+ if (rc)
+ return rc;
+ } else if (daxctl_dev_is_devdax_mode(dev)) {
+ /* already in devdax mode, just re-enable */
+ rc = daxctl_dev_disable(dev);
+ if (rc) {
+ fprintf(stderr, "%s: disable failed: %s\n",
+ devname, strerror(-rc));
+ return rc;
+ }
+ } else {
+ fprintf(stderr, "%s: unknown mode\n", devname);
+ return -EINVAL;
+ }
}

rc = daxctl_dev_enable_devdax(dev);
@@ -801,6 +873,43 @@ static int reconfig_mode_devdax(struct daxctl_dev *dev)
return 0;
}

+static int reconfig_mode_famfs(struct daxctl_dev *dev)
+{
+ struct daxctl_memory *mem = daxctl_dev_get_memory(dev);
+ const char *devname = daxctl_dev_get_devname(dev);
+ int rc;
+
+ if (daxctl_dev_is_enabled(dev)) {
+ if (mem) {
+ fprintf(stderr,
+ "%s is in system-ram mode; must be in devdax mode to convert to famfs\n",
+ devname);
+ return -EINVAL;
+ } else if (daxctl_dev_is_famfs_mode(dev)) {
+ /* already in famfs mode, just re-enable */
+ rc = daxctl_dev_disable(dev);
+ if (rc) {
+ fprintf(stderr, "%s: disable failed: %s\n",
+ devname, strerror(-rc));
+ return rc;
+ }
+ } else if (daxctl_dev_is_devdax_mode(dev)) {
+ rc = disable_devdax_device(dev);
+ if (rc)
+ return rc;
+ } else {
+ fprintf(stderr, "%s: unknown mode\n", devname);
+ return -EINVAL;
+ }
+ }
+
+ rc = daxctl_dev_enable_famfs(dev);
+ if (rc)
+ return rc;
+
+ return 0;
+}
+
static int do_create(struct daxctl_region *region, long long val,
struct json_object **jdevs)
{
@@ -887,6 +996,9 @@ static int do_reconfig(struct daxctl_dev *dev, enum dev_mode mode,
case DAXCTL_DEV_MODE_DEVDAX:
rc = reconfig_mode_devdax(dev);
break;
+ case DAXCTL_DEV_MODE_FAMFS:
+ rc = reconfig_mode_famfs(dev);
+ break;
default:
fprintf(stderr, "%s: unknown mode requested: %d\n",
devname, mode);
diff --git a/daxctl/json.c b/daxctl/json.c
index 3cbce9d..2a4b12c 100644
--- a/daxctl/json.c
+++ b/daxctl/json.c
@@ -48,8 +48,19 @@ struct json_object *util_daxctl_dev_to_json(struct daxctl_dev *dev,

if (mem)
jobj = json_object_new_string("system-ram");
- else
+ else if (daxctl_dev_is_famfs_mode(dev))
+ jobj = json_object_new_string("famfs");
+ else if (daxctl_dev_is_devdax_mode(dev))
jobj = json_object_new_string("devdax");
+ else {
+ /* Legacy condition; if a daxdev is not in any "mode", that
+ * means no driver is bound. We report that as a disabled
+ * device in devdax mode. (the disabled modifier is added later
+ * in this function if applicable)
+ */
+ jobj = json_object_new_string("devdax");
+ }
+
if (jobj)
json_object_object_add(jdev, "mode", jobj);

diff --git a/daxctl/lib/libdaxctl-private.h b/daxctl/lib/libdaxctl-private.h
index ae45311..0bb73e8 100644
--- a/daxctl/lib/libdaxctl-private.h
+++ b/daxctl/lib/libdaxctl-private.h
@@ -21,12 +21,14 @@ static const char *dax_subsystems[] = {
enum daxctl_dev_mode {
DAXCTL_DEV_MODE_DEVDAX = 0,
DAXCTL_DEV_MODE_RAM,
+ DAXCTL_DEV_MODE_FAMFS,
DAXCTL_DEV_MODE_END,
};

static const char *dax_modules[] = {
[DAXCTL_DEV_MODE_DEVDAX] = "device_dax",
[DAXCTL_DEV_MODE_RAM] = "kmem",
+ [DAXCTL_DEV_MODE_FAMFS] = "fsdev_dax",
};

enum memory_op {
diff --git a/daxctl/lib/libdaxctl.c b/daxctl/lib/libdaxctl.c
index 02ae7e5..33121dc 100644
--- a/daxctl/lib/libdaxctl.c
+++ b/daxctl/lib/libdaxctl.c
@@ -385,13 +385,13 @@ static bool device_model_is_dax_bus(struct daxctl_dev *dev)
return false;
}

-DAXCTL_EXPORT int daxctl_dev_is_system_ram_capable(struct daxctl_dev *dev)
+static int daxctl_dev_bound_to_module(struct daxctl_dev *dev, const char *mod_name)
{
const char *devname = daxctl_dev_get_devname(dev);
struct daxctl_ctx *ctx = daxctl_dev_get_ctx(dev);
const char *mod_base;
char *mod_path;
- char path[200];
+ char path[PATH_MAX];
const int len = sizeof(path);

if (!device_model_is_dax_bus(dev))
@@ -406,11 +406,13 @@ DAXCTL_EXPORT int daxctl_dev_is_system_ram_capable(struct daxctl_dev *dev)
}

mod_path = realpath(path, NULL);
- if (!mod_path)
+ if (!mod_path) {
+ dbg(ctx, "%s: realpath failed for driver link\n", devname);
return false;
+ }

mod_base = path_basename(mod_path);
- if (strcmp(mod_base, dax_modules[DAXCTL_DEV_MODE_RAM]) == 0) {
+ if (strcmp(mod_base, mod_name) == 0) {
free(mod_path);
return true;
}
@@ -419,6 +421,30 @@ DAXCTL_EXPORT int daxctl_dev_is_system_ram_capable(struct daxctl_dev *dev)
return false;
}

+DAXCTL_EXPORT int daxctl_dev_is_system_ram_capable(struct daxctl_dev *dev)
+{
+ return daxctl_dev_bound_to_module(dev, dax_modules[DAXCTL_DEV_MODE_RAM]);
+}
+
+/*
+ * Check if device is currently in famfs mode (bound to fsdev_dax driver).
+ * Returns false for disabled devices: the DAX bus does not retain the previous
+ * driver binding after unbind, so mode cannot be determined without a driver.
+ */
+DAXCTL_EXPORT int daxctl_dev_is_famfs_mode(struct daxctl_dev *dev)
+{
+ return daxctl_dev_bound_to_module(dev, dax_modules[DAXCTL_DEV_MODE_FAMFS]);
+}
+
+/*
+ * Check if device is currently in devdax mode (bound to device_dax driver).
+ * Returns false for disabled devices; see daxctl_dev_is_famfs_mode().
+ */
+DAXCTL_EXPORT int daxctl_dev_is_devdax_mode(struct daxctl_dev *dev)
+{
+ return daxctl_dev_bound_to_module(dev, dax_modules[DAXCTL_DEV_MODE_DEVDAX]);
+}
+
/*
* This checks for the device to be in system-ram mode, so calling
* daxctl_dev_get_memory() on a devdax mode device will always return NULL.
@@ -983,6 +1009,11 @@ DAXCTL_EXPORT int daxctl_dev_enable_ram(struct daxctl_dev *dev)
return daxctl_dev_enable(dev, DAXCTL_DEV_MODE_RAM);
}

+DAXCTL_EXPORT int daxctl_dev_enable_famfs(struct daxctl_dev *dev)
+{
+ return daxctl_dev_enable(dev, DAXCTL_DEV_MODE_FAMFS);
+}
+
DAXCTL_EXPORT int daxctl_dev_disable(struct daxctl_dev *dev)
{
const char *devname = daxctl_dev_get_devname(dev);
diff --git a/daxctl/lib/libdaxctl.sym b/daxctl/lib/libdaxctl.sym
index 3098811..2a812c6 100644
--- a/daxctl/lib/libdaxctl.sym
+++ b/daxctl/lib/libdaxctl.sym
@@ -104,3 +104,10 @@ LIBDAXCTL_10 {
global:
daxctl_dev_is_system_ram_capable;
} LIBDAXCTL_9;
+
+LIBDAXCTL_11 {
+global:
+ daxctl_dev_enable_famfs;
+ daxctl_dev_is_famfs_mode;
+ daxctl_dev_is_devdax_mode;
+} LIBDAXCTL_10;
diff --git a/daxctl/libdaxctl.h b/daxctl/libdaxctl.h
index 53c6bbd..84fcdb4 100644
--- a/daxctl/libdaxctl.h
+++ b/daxctl/libdaxctl.h
@@ -72,12 +72,15 @@ int daxctl_dev_is_enabled(struct daxctl_dev *dev);
int daxctl_dev_disable(struct daxctl_dev *dev);
int daxctl_dev_enable_devdax(struct daxctl_dev *dev);
int daxctl_dev_enable_ram(struct daxctl_dev *dev);
+int daxctl_dev_enable_famfs(struct daxctl_dev *dev);
int daxctl_dev_get_target_node(struct daxctl_dev *dev);
int daxctl_dev_will_auto_online_memory(struct daxctl_dev *dev);
int daxctl_dev_has_online_memory(struct daxctl_dev *dev);

struct daxctl_memory;
int daxctl_dev_is_system_ram_capable(struct daxctl_dev *dev);
+int daxctl_dev_is_famfs_mode(struct daxctl_dev *dev);
+int daxctl_dev_is_devdax_mode(struct daxctl_dev *dev);
struct daxctl_memory *daxctl_dev_get_memory(struct daxctl_dev *dev);
struct daxctl_dev *daxctl_memory_get_dev(struct daxctl_memory *mem);
const char *daxctl_memory_get_node_path(struct daxctl_memory *mem);
--
2.53.0


\
 
 \ /
  Last update: 2026-04-30 17:36    [W:0.114 / U:44.522 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and my Meterkast|Read the blog