commit: faf1a61fa73e2ec62da03cfc81255b4fbdeaf0e1
Author: Michał Górny <mgorny <AT> gentoo <DOT> org>
AuthorDate: Thu Nov 27 11:15:37 2025 +0000
Commit: Michał Górny <mgorny <AT> gentoo <DOT> org>
CommitDate: Thu Nov 27 11:15:37 2025 +0000
URL: https://gitweb.gentoo.org/proj/steve.git/commit/?id=faf1a61f
Use std::print for formatting
Signed-off-by: Michał Górny <mgorny <AT> gentoo.org>
steve.cxx | 61 +++++++++++++++++++++++++++++++------------------------------
1 file changed, 31 insertions(+), 30 deletions(-)
diff --git a/steve.cxx b/steve.cxx
index 5397a19..52ff9e6 100644
--- a/steve.cxx
+++ b/steve.cxx
@@ -19,6 +19,7 @@
#include <deque>
#include <functional>
#include <memory>
+#include <print>
#include <string>
#include <unordered_map>
@@ -87,7 +88,7 @@ static void steve_wake_waiters(steve_state *state)
state->tokens--;
state->processes[read_waiter->pid].tokens_held++;
if (state->verbose)
- fprintf(stderr, "Giving job token to PID %ld, %d left,
%d tokens held by process\n",
+ std::print(stderr, "Giving job token to PID {}, {}
left, {} tokens held by process\n",
read_waiter->pid, state->tokens,
state->processes[read_waiter->pid].tokens_held);
fuse_reply_buf(read_waiter->req, "+", 1);
state->read_waiters.pop_front();
@@ -96,7 +97,7 @@ static void steve_wake_waiters(steve_state *state)
if (state->tokens > 0) {
for (auto &poll_waiter : state->poll_waiters) {
if (state->verbose)
- fprintf(stderr, "Notifying PID %ld about
POLLIN, %d tokens left, %d tokens held by process\n",
+ std::print(stderr, "Notifying PID {} about
POLLIN, {} tokens left, {} tokens held by process\n",
poll_waiter.pid, state->tokens,
state->processes[poll_waiter.pid].tokens_held);
fuse_lowlevel_notify_poll(poll_waiter.poll_handle);
}
@@ -111,8 +112,8 @@ static void steve_handle_pidfd(evutil_socket_t pid_fd,
short, void *userdata) {
if (it->second.pid_fd == pid_fd) {
state->tokens += it->second.tokens_held;
if (state->verbose || it->second.tokens_held > 0) {
- fprintf(stderr, "Process %ld exited while
holding %d tokens, "
- "%d tokens available after
returning them\n",
+ std::print(stderr, "Process {} exited while
holding {} tokens, "
+ "{} tokens available after
returning them\n",
it->first,
it->second.tokens_held, state->tokens);
}
state->processes.erase(it);
@@ -130,7 +131,7 @@ static void steve_init(void *userdata, struct
fuse_conn_info *)
state->tokens = state->jobs;
- fprintf(stderr, "steve running on /dev/steve for %d jobs\n",
state->jobs);
+ std::print(stderr, "steve running on /dev/steve for {} jobs\n",
state->jobs);
}
static void steve_destroy(void *userdata)
@@ -167,13 +168,13 @@ static void steve_open(fuse_req_t req, struct
fuse_file_info *fi)
std::unique_ptr<struct event, std::function<void(struct
event*)>>
pidfd_event{event_new(state->evb, pid_fd,
EV_READ|EV_PERSIST, steve_handle_pidfd, state), event_free};
if (!pidfd_event) {
- fprintf(stderr, "unable to allocate event for pidfd");
+ std::print(stderr, "unable to allocate event for
pidfd");
close(pid_fd);
fuse_reply_err(req, EIO);
return;
}
if (event_add(pidfd_event.get(), nullptr) == -1) {
- fprintf(stderr, "failed to enable pidfd handler");
+ std::print(stderr, "failed to enable pidfd handler");
close(pid_fd);
fuse_reply_err(req, EIO);
return;
@@ -184,7 +185,7 @@ static void steve_open(fuse_req_t req, struct
fuse_file_info *fi)
}
if (state->verbose)
- fprintf(stderr, "Device open by PID %ld (pidfd %d)\n", fi->fh,
pid_fd);
+ std::print(stderr, "Device open by PID {} (pidfd {})\n",
fi->fh, pid_fd);
fuse_reply_open(req, fi);
}
@@ -194,7 +195,7 @@ static void steve_release(fuse_req_t req, struct
fuse_file_info *fi)
steve_state *state = static_cast<steve_state *>(fuse_req_userdata(req));
if (state->verbose)
- fprintf(stderr, "Device closed by PID %ld\n", fi->fh);
+ std::print(stderr, "Device closed by PID {}\n", fi->fh);
fuse_reply_err(req, 0);
}
@@ -207,7 +208,7 @@ static void steve_interrupt(fuse_req_t req, void *userdata)
for (auto it = state->read_waiters.begin(); it !=
state->read_waiters.end(); ++it) {
if (it->req == req) {
if (state->verbose)
- fprintf(stderr, "Passed EINTR to PID %ld\n",
it->pid);
+ std::print(stderr, "Passed EINTR to PID {}\n",
it->pid);
state->read_waiters.erase(it);
break;
}
@@ -233,7 +234,7 @@ static void steve_read(
state->tokens--;
state->processes[fi->fh].tokens_held++;
if (state->verbose)
- fprintf(stderr, "Giving job token to PID %ld, %d left,
%d tokens held by process\n",
+ std::print(stderr, "Giving job token to PID {}, {}
left, {} tokens held by process\n",
fi->fh, state->tokens,
state->processes[fi->fh].tokens_held);
fuse_reply_buf(req, "+", 1);
return;
@@ -246,7 +247,7 @@ static void steve_read(
state->read_waiters.emplace_back(steve_read_waiter{req, fi->fh});
if (state->verbose)
- fprintf(stderr, "No free job token for PID %ld, waiting, %d
tokens held by process\n",
+ std::print(stderr, "No free job token for PID {}, waiting, {}
tokens held by process\n",
fi->fh, state->processes[fi->fh].tokens_held);
fuse_req_interrupt_func(req, steve_interrupt, state);
}
@@ -263,7 +264,7 @@ static void steve_write(
}
if (state->processes[fi->fh].tokens_held < size) {
- fprintf(stderr, "Warning: process %ld tried to return %zd
tokens while holding only %d tokens, capping\n",
+ std::print(stderr, "Warning: process {} tried to return {}
tokens while holding only {} tokens, capping\n",
fi->fh, size,
state->processes[fi->fh].tokens_held);
size = state->processes[fi->fh].tokens_held;
}
@@ -275,7 +276,7 @@ static void steve_write(
state->tokens += size;
state->processes[fi->fh].tokens_held -= size;
if (state->verbose)
- fprintf(stderr, "PID %ld returned %zd tokens, %d available now,
%d tokens held by process\n",
+ std::print(stderr, "PID {} returned {} tokens, {} available
now, {} tokens held by process\n",
fi->fh, size, state->tokens,
state->processes[fi->fh].tokens_held);
fuse_reply_write(req, size);
@@ -290,7 +291,7 @@ static void steve_poll(
int events = fi->poll_events & (POLLIN | POLLOUT);
if (state->verbose)
- fprintf(stderr, "PID %ld requested poll, %d tokens available,
%d tokens held by process\n",
+ std::print(stderr, "PID {} requested poll, {} tokens available,
{} tokens held by process\n",
fi->fh, state->tokens,
state->processes[fi->fh].tokens_held);
/* POLLOUT is always possible, POLLIN only if we have any tokens */
@@ -318,10 +319,10 @@ static const struct cuse_lowlevel_ops steve_ops = {
static void steve_handle_sigusr1(evutil_socket_t, short, void *userdata) {
steve_state *state = static_cast<steve_state *>(userdata);
- fprintf(stderr, "steve: currently %d tokens available out of %d\n",
+ std::print(stderr, "steve: currently {} tokens available out of {}\n",
state->tokens, state->jobs);
for (auto &it : state->processes) {
- fprintf(stderr, "PID %ld holds %d tokens\n", it.first,
it.second.tokens_held);
+ std::print(stderr, "PID {} holds {} tokens\n", it.first,
it.second.tokens_held);
}
}
@@ -332,8 +333,8 @@ static void steve_handle_cuse(evutil_socket_t, short, void
*userdata) {
fuse_session_process_buf(state->session, &state->buf);
}
-static const char *steve_usage =
-"usage: %s [options]\n"
+static constexpr char steve_usage[] =
+"usage: {} [options]\n"
"\n"
"options:\n"
" --help, -h print this help message\n"
@@ -365,10 +366,10 @@ int main(int argc, char **argv)
while ((opt = getopt_long(argc, argv, "hVj:vd", steve_opts, nullptr))
!= -1) {
switch (opt) {
case 'h':
- printf(steve_usage, argv[0]);
+ std::print(steve_usage, argv[0]);
return 0;
case 'V':
- printf("steve %s\n", STEVE_VERSION);
+ std::print("steve {}\n", STEVE_VERSION);
return 0;
case 'j':
{
@@ -376,7 +377,7 @@ int main(int argc, char **argv)
errno = 0;
long jobs_arg = strtol(optarg, &endptr,
10);
if (*endptr || errno == ERANGE ||
jobs_arg < 0 || jobs_arg > INT_MAX) {
- fprintf(stderr, "invalid job
number: %s\n", optarg);
+ std::print(stderr, "invalid job
number: {}\n", optarg);
return 1;
}
state.jobs = jobs_arg;
@@ -389,7 +390,7 @@ int main(int argc, char **argv)
debug = true;
break;
default:
- fprintf(stderr, steve_usage, argv[0]);
+ std::print(stderr, steve_usage, argv[0]);
return 1;
}
}
@@ -397,7 +398,7 @@ int main(int argc, char **argv)
std::unique_ptr<struct event_base, std::function<void(struct
event_base*)>>
evb{event_base_new(), event_base_free};
if (!evb) {
- fprintf(stderr, "failed to initialize libevent\n");
+ std::print(stderr, "failed to initialize libevent\n");
return 1;
}
state.evb = evb.get();
@@ -427,7 +428,7 @@ int main(int argc, char **argv)
std::unique_ptr<struct fuse_session, std::function<void(struct
fuse_session*)>> session{
cuse_lowlevel_new(args_ptr.get(), &ci, &steve_ops, &state),
fuse_session_destroy};
if (!session) {
- fprintf(stderr, "failed to initialize FUSE");
+ std::print(stderr, "failed to initialize FUSE");
return 1;
}
state.session = session.get();
@@ -435,28 +436,28 @@ int main(int argc, char **argv)
std::unique_ptr<struct event, std::function<void(struct event*)>>
cuse_event{event_new(evb.get(), cuse_fd, EV_READ|EV_PERSIST,
steve_handle_cuse, &state), event_free};
if (!cuse_event) {
- fprintf(stderr, "failed to initialize CUSE handler");
+ std::print(stderr, "failed to initialize CUSE handler");
return 1;
}
if (event_add(cuse_event.get(), nullptr) == -1) {
- fprintf(stderr, "failed to enable CUSE handler");
+ std::print(stderr, "failed to enable CUSE handler");
return 1;
}
std::unique_ptr<struct event, std::function<void(struct event*)>>
sigusr1_event{evsignal_new(evb.get(), SIGUSR1,
steve_handle_sigusr1, &state), event_free};
if (!sigusr1_event) {
- fprintf(stderr, "failed to initialize SIGUSR1 handler");
+ std::print(stderr, "failed to initialize SIGUSR1 handler");
return 1;
}
if (event_add(sigusr1_event.get(), nullptr) == -1) {
- fprintf(stderr, "failed to enable SIGUSR1 handler");
+ std::print(stderr, "failed to enable SIGUSR1 handler");
return 1;
}
std::string mountpoint = "/dev/fd/" + std::to_string(cuse_fd);
if (fuse_session_mount(session.get(), mountpoint.c_str()) == -1) {
- fprintf(stderr, "failed to mount the filesystem");
+ std::print(stderr, "failed to mount the filesystem");
return 1;
}
