The branch main has been updated by kib:

URL: 
https://cgit.FreeBSD.org/src/commit/?id=58e5f3b84df0aeaaf4b56a5e48bcb4b3e1d9c097

commit 58e5f3b84df0aeaaf4b56a5e48bcb4b3e1d9c097
Author:     Konstantin Belousov <[email protected]>
AuthorDate: 2025-10-25 08:37:14 +0000
Commit:     Konstantin Belousov <[email protected]>
CommitDate: 2025-11-04 04:11:11 +0000

    sys/: rename bio_error variable to abio_error
    
    to prevent future name collision with some buf/bio macros
    
    Reviewed by:    mckusick
    Sponsored by:   The FreeBSD Foundation
    Differential revision:  https://reviews.freebsd.org/D53351
---
 sys/dev/mmc/mmcsd.c    |  8 ++++----
 sys/dev/nvme/nvme_ns.c | 14 +++++++-------
 sys/kern/vfs_aio.c     | 10 +++++-----
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/sys/dev/mmc/mmcsd.c b/sys/dev/mmc/mmcsd.c
index 5b9cb93c7b31..f2965048b285 100644
--- a/sys/dev/mmc/mmcsd.c
+++ b/sys/dev/mmc/mmcsd.c
@@ -1422,7 +1422,7 @@ mmcsd_task(void *arg)
        struct mmcsd_softc *sc;
        struct bio *bp;
        device_t dev, mmcbus;
-       int bio_error, err, sz;
+       int abio_error, err, sz;
 
        part = arg;
        sc = part->sc;
@@ -1430,7 +1430,7 @@ mmcsd_task(void *arg)
        mmcbus = sc->mmcbus;
 
        while (1) {
-               bio_error = 0;
+               abio_error = 0;
                MMCSD_DISK_LOCK(part);
                do {
                        if (part->running == 0)
@@ -1475,11 +1475,11 @@ mmcsd_task(void *arg)
                } else if (bp->bio_cmd == BIO_DELETE)
                        block = mmcsd_delete(part, bp);
                else
-                       bio_error = EOPNOTSUPP;
+                       abio_error = EOPNOTSUPP;
 release:
                MMCBUS_RELEASE_BUS(mmcbus, dev);
                if (block < end) {
-                       bp->bio_error = (bio_error == 0) ? EIO : bio_error;
+                       bp->bio_error = (abio_error == 0) ? EIO : abio_error;
                        bp->bio_resid = (end - block) * sz;
                        bp->bio_flags |= BIO_ERROR;
                } else
diff --git a/sys/dev/nvme/nvme_ns.c b/sys/dev/nvme/nvme_ns.c
index f4a588373c98..17684cc14ba2 100644
--- a/sys/dev/nvme/nvme_ns.c
+++ b/sys/dev/nvme/nvme_ns.c
@@ -45,7 +45,7 @@
 #include "nvme_private.h"
 #include "nvme_linux.h"
 
-static void            nvme_bio_child_inbed(struct bio *parent, int bio_error);
+static void            nvme_bio_child_inbed(struct bio *parent, int 
abio_error);
 static void            nvme_bio_child_done(void *arg,
                                            const struct nvme_completion *cpl);
 static uint32_t                nvme_get_num_segments(uint64_t addr, uint64_t 
size,
@@ -275,14 +275,14 @@ nvme_ns_bio_done(void *arg, const struct nvme_completion 
*status)
 }
 
 static void
-nvme_bio_child_inbed(struct bio *parent, int bio_error)
+nvme_bio_child_inbed(struct bio *parent, int abio_error)
 {
        struct nvme_completion  parent_cpl;
        int                     children, inbed;
 
-       if (bio_error != 0) {
+       if (abio_error != 0) {
                parent->bio_flags |= BIO_ERROR;
-               parent->bio_error = bio_error;
+               parent->bio_error = abio_error;
        }
 
        /*
@@ -309,12 +309,12 @@ nvme_bio_child_done(void *arg, const struct 
nvme_completion *cpl)
 {
        struct bio              *child = arg;
        struct bio              *parent;
-       int                     bio_error;
+       int                     abio_error;
 
        parent = child->bio_parent;
        g_destroy_bio(child);
-       bio_error = nvme_completion_is_error(cpl) ? EIO : 0;
-       nvme_bio_child_inbed(parent, bio_error);
+       abio_error = nvme_completion_is_error(cpl) ? EIO : 0;
+       nvme_bio_child_inbed(parent, abio_error);
 }
 
 static uint32_t
diff --git a/sys/kern/vfs_aio.c b/sys/kern/vfs_aio.c
index 60916a9fbd32..02d4b8426757 100644
--- a/sys/kern/vfs_aio.c
+++ b/sys/kern/vfs_aio.c
@@ -2487,7 +2487,7 @@ aio_biowakeup(struct bio *bp)
        long bcount = bp->bio_bcount;
        long resid = bp->bio_resid;
        int opcode, nblks;
-       int bio_error = bp->bio_error;
+       int abio_error = bp->bio_error;
        uint16_t flags = bp->bio_flags;
 
        opcode = job->uaiocb.aio_lio_opcode;
@@ -2503,16 +2503,16 @@ aio_biowakeup(struct bio *bp)
         * error of whichever failed bio completed last.
         */
        if (flags & BIO_ERROR)
-               atomic_store_int(&job->error, bio_error);
+               atomic_store_int(&job->error, abio_error);
        if (opcode & LIO_WRITE)
                atomic_add_int(&job->outblock, nblks);
        else
                atomic_add_int(&job->inblock, nblks);
 
        if (refcount_release(&job->nbio)) {
-               bio_error = atomic_load_int(&job->error);
-               if (bio_error != 0)
-                       aio_complete(job, -1, bio_error);
+               abio_error = atomic_load_int(&job->error);
+               if (abio_error != 0)
+                       aio_complete(job, -1, abio_error);
                else
                        aio_complete(job, atomic_load_long(&job->nbytes), 0);
        }

Reply via email to