/* $NetBSD: udf_strat_direct.c,v 1.17 2024/02/10 09:21:53 andvar Exp $ */

/*
* Copyright (c) 2006, 2008 Reinoud Zandijk
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#include <sys/cdefs.h>
#ifndef lint
__KERNEL_RCSID(0, "$NetBSD: udf_strat_direct.c,v 1.17 2024/02/10 09:21:53 andvar Exp $");
#endif /* not lint */


#if defined(_KERNEL_OPT)
#include "opt_compat_netbsd.h"
#endif

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/sysctl.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/kernel.h>
#include <sys/vnode.h>
#include <miscfs/genfs/genfs_node.h>
#include <sys/mount.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/device.h>
#include <sys/disklabel.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/dirent.h>
#include <sys/stat.h>
#include <sys/conf.h>
#include <sys/kauth.h>
#include <sys/kthread.h>
#include <dev/clock_subr.h>

#include <fs/udf/ecma167-udf.h>
#include <fs/udf/udf_mount.h>

#include "udf.h"
#include "udf_subr.h"
#include "udf_bswap.h"


#define VTOI(vnode) ((struct udf_node *) vnode->v_data)
#define PRIV(ump) ((struct strat_private *) ump->strategy_private)

/* --------------------------------------------------------------------- */

/* BUFQ's */
#define UDF_SHED_MAX 3

#define UDF_SHED_READING        0
#define UDF_SHED_WRITING        1
#define UDF_SHED_SEQWRITING     2


struct strat_private {
       struct pool             desc_pool;       /* node descriptors */
};

/* --------------------------------------------------------------------- */

static void
udf_wr_nodedscr_callback(struct buf *buf)
{
       struct udf_node *udf_node;

       KASSERT(buf);
       KASSERT(buf->b_data);

       /* called when write action is done */
       DPRINTF(WRITE, ("udf_wr_nodedscr_callback(): node written out\n"));

       udf_node = VTOI(buf->b_vp);
       if (udf_node == NULL) {
               putiobuf(buf);
               printf("udf_wr_node_callback: NULL node?\n");
               return;
       }

       /* XXX right flags to mark dirty again on error? */
       if (buf->b_error) {
               /* write error on `defect free' media??? how to solve? */
               /* XXX lookup UDF standard for unallocatable space */
               udf_node->i_flags |= IN_MODIFIED | IN_ACCESSED;
       }

       /* decrement outstanding_nodedscr */
       KASSERT(udf_node->outstanding_nodedscr >= 1);
       udf_node->outstanding_nodedscr--;
       if (udf_node->outstanding_nodedscr == 0) {
               /* unlock the node */
               UDF_UNLOCK_NODE(udf_node, 0);
               cv_broadcast(&udf_node->node_lock);
       }

       putiobuf(buf);
}

/* --------------------------------------------------------------------- */

static int
udf_getblank_nodedscr_direct(struct udf_strat_args *args)
{
       union dscrptr   **dscrptr = &args->dscr;
       struct udf_mount *ump = args->ump;
       struct strat_private *priv = PRIV(ump);
       uint32_t lb_size;

       lb_size = udf_rw32(ump->logical_vol->lb_size);
       *dscrptr = pool_get(&priv->desc_pool, PR_WAITOK);
       memset(*dscrptr, 0, lb_size);

       return 0;
}


static void
udf_free_nodedscr_direct(struct udf_strat_args *args)
{
       union dscrptr    *dscr = args->dscr;
       struct udf_mount *ump  = args->ump;
       struct strat_private *priv = PRIV(ump);

       pool_put(&priv->desc_pool, dscr);
}


static int
udf_read_nodedscr_direct(struct udf_strat_args *args)
{
       union dscrptr   **dscrptr = &args->dscr;
       union dscrptr    *tmpdscr;
       struct udf_mount *ump = args->ump;
       struct long_ad   *icb = args->icb;
       struct strat_private *priv = PRIV(ump);
       uint32_t lb_size;
       uint32_t sector, dummy;
       int error;

       lb_size = udf_rw32(ump->logical_vol->lb_size);

       error = udf_translate_vtop(ump, icb, &sector, &dummy);
       if (error)
               return error;

       /* try to read in fe/efe */
       error = udf_read_phys_dscr(ump, sector, M_UDFTEMP, &tmpdscr);
       if (error)
               return error;

       *dscrptr = pool_get(&priv->desc_pool, PR_WAITOK);
       memcpy(*dscrptr, tmpdscr, lb_size);
       free(tmpdscr, M_UDFTEMP);

       return 0;
}


static int
udf_write_nodedscr_direct(struct udf_strat_args *args)
{
       struct udf_mount *ump      = args->ump;
       struct udf_node  *udf_node = args->udf_node;
       union dscrptr    *dscr     = args->dscr;
       struct long_ad   *icb      = args->icb;
       int               waitfor  = args->waitfor;
       uint32_t logsector, sector, dummy;
       int error, vpart __diagused;

       /*
        * we have to decide if we write it out sequential or at its fixed
        * position by examining the partition its (to be) written on.
        */
       vpart     = udf_rw16(udf_node->loc.loc.part_num);
       logsector = udf_rw32(icb->loc.lb_num);
       KASSERT(ump->vtop_tp[vpart] != UDF_VTOP_TYPE_VIRT);

       sector = 0;
       error  = udf_translate_vtop(ump, icb, &sector, &dummy);
       if (error)
               goto out;

       if (waitfor) {
               DPRINTF(WRITE, ("udf_write_nodedscr: sync write\n"));

               error = udf_write_phys_dscr_sync(ump, udf_node, UDF_C_NODE,
                       dscr, sector, logsector);
       } else {
               DPRINTF(WRITE, ("udf_write_nodedscr: no wait, async write\n"));

               error = udf_write_phys_dscr_async(ump, udf_node, UDF_C_NODE,
                       dscr, sector, logsector, udf_wr_nodedscr_callback);
               /* will be UNLOCKED in call back */
               return error;
       }
out:
       udf_node->outstanding_nodedscr--;
       if (udf_node->outstanding_nodedscr == 0) {
               UDF_UNLOCK_NODE(udf_node, 0);
               cv_broadcast(&udf_node->node_lock);
       }

       return error;
}

/* --------------------------------------------------------------------- */

static void
udf_queue_buf_direct(struct udf_strat_args *args)
{
       struct udf_mount *ump = args->ump;
       struct buf *buf = args->nestbuf;
       struct buf *nestbuf;
       struct desc_tag *tag;
       struct long_ad *node_ad_cpy;
       uint64_t *lmapping, *pmapping, *lmappos, run_start;
       uint32_t sectornr;
       uint32_t buf_offset, rbuflen, bpos;
       uint16_t vpart_num;
       uint8_t *fidblk;
       off_t rblk;
       int sector_size = ump->discinfo.sector_size;
       int len, buf_len, sector, sectors, run_length;
       int blks = sector_size / DEV_BSIZE;
       int what, class __diagused, queue;

       KASSERT(ump);
       KASSERT(buf);
       KASSERT(buf->b_iodone == nestiobuf_iodone);

       what = buf->b_udf_c_type;
       queue = UDF_SHED_READING;
       if ((buf->b_flags & B_READ) == 0) {
               /* writing */
               queue = UDF_SHED_SEQWRITING;
               if (what == UDF_C_ABSOLUTE)
                       queue = UDF_SHED_WRITING;
               if (what == UDF_C_DSCR)
                       queue = UDF_SHED_WRITING;
               if (what == UDF_C_NODE)
                       queue = UDF_SHED_WRITING;
       }

       /* use disc scheduler */
       class = ump->discinfo.mmc_class;
       KASSERT((class == MMC_CLASS_UNKN) || (class == MMC_CLASS_DISC) ||
               (ump->discinfo.mmc_cur & MMC_CAP_HW_DEFECTFREE) ||
               (ump->vfs_mountp->mnt_flag & MNT_RDONLY));

#ifndef UDF_DEBUG
       __USE(blks);
#endif
       if (queue == UDF_SHED_READING) {
               DPRINTF(SHEDULE, ("\nudf_issue_buf READ %p : sector %d type %d,"
                       "b_resid %d, b_bcount %d, b_bufsize %d\n",
                       buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type,
                       buf->b_resid, buf->b_bcount, buf->b_bufsize));
               VOP_STRATEGY(ump->devvp, buf);
               return;
       }


       if (queue == UDF_SHED_WRITING) {
               DPRINTF(SHEDULE, ("\nudf_issue_buf WRITE %p : sector %d "
                       "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n",
                       buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type,
                       buf->b_resid, buf->b_bcount, buf->b_bufsize));
               KASSERT(buf->b_udf_c_type == UDF_C_DSCR ||
                       buf->b_udf_c_type == UDF_C_ABSOLUTE ||
                       buf->b_udf_c_type == UDF_C_NODE);
                udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type);
               VOP_STRATEGY(ump->devvp, buf);
               return;
       }

       /* UDF_SHED_SEQWRITING */
       KASSERT(queue == UDF_SHED_SEQWRITING);
       DPRINTF(SHEDULE, ("\nudf_issue_buf SEQWRITE %p : sector XXXX "
               "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n",
               buf, buf->b_udf_c_type, buf->b_resid, buf->b_bcount,
               buf->b_bufsize));

       /*
        * Buffers should not have been allocated to disc addresses yet on
        * this queue. Note that a buffer can get multiple extents allocated.
        *
        * lmapping contains lb_num relative to base partition.
        */
       lmapping    = ump->la_lmapping;
       node_ad_cpy = ump->la_node_ad_cpy;

       /* logically allocate buf and map it in the file */
       udf_late_allocate_buf(ump, buf, lmapping, node_ad_cpy, &vpart_num);

       /* if we have FIDs, fixup using the new allocation table */
       if (buf->b_udf_c_type == UDF_C_FIDS) {
               buf_len = buf->b_bcount;
               bpos = 0;
               lmappos = lmapping;
               while (buf_len) {
                       sectornr = *lmappos++;
                       len = MIN(buf_len, sector_size);
                       fidblk = (uint8_t *) buf->b_data + bpos;
                       udf_fixup_fid_block(fidblk, sector_size,
                               0, len, sectornr);
                       bpos += len;
                       buf_len -= len;
               }
       }
       if (buf->b_udf_c_type == UDF_C_METADATA_SBM) {
               if (buf->b_lblkno == 0) {
                       /* update the tag location inside */
                       tag = (struct desc_tag *) buf->b_data;
                       tag->tag_loc = udf_rw32(*lmapping);
                       udf_validate_tag_and_crc_sums(buf->b_data);
               }
       }
       udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type);

       /*
        * Translate new mappings in lmapping to pmappings and try to
        * conglomerate extents to reduce the number of writes.
        *
        * pmapping to contain lb_nums as used for disc addressing.
        */
       pmapping = ump->la_pmapping;
       sectors  = (buf->b_bcount + sector_size -1) / sector_size;
       udf_translate_vtop_list(ump, sectors, vpart_num, lmapping, pmapping);

       for (sector = 0; sector < sectors; sector++) {
               buf_offset = sector * sector_size;
               DPRINTF(WRITE, ("\tprocessing rel sector %d\n", sector));

               DPRINTF(WRITE, ("\tissue write sector %"PRIu64"\n",
                       pmapping[sector]));

               run_start  = pmapping[sector];
               run_length = 1;
               while (sector < sectors-1) {
                       if (pmapping[sector+1] != pmapping[sector]+1)
                               break;
                       run_length++;
                       sector++;
               }

               /* nest an iobuf for the extent */
               rbuflen = run_length *  sector_size;
               rblk    = run_start  * (sector_size/DEV_BSIZE);

               nestbuf = getiobuf(NULL, true);
               nestiobuf_setup(buf, nestbuf, buf_offset, rbuflen);
               /* nestbuf is B_ASYNC */

               /* identify this nestbuf */
               nestbuf->b_lblkno   = sector;
               assert(nestbuf->b_vp == buf->b_vp);

               /* CD schedules on raw blkno */
               nestbuf->b_blkno      = rblk;
               nestbuf->b_proc       = NULL;
               nestbuf->b_rawblkno   = rblk;
               nestbuf->b_udf_c_type = UDF_C_PROCESSED;

               VOP_STRATEGY(ump->devvp, nestbuf);
       }
}


static void
udf_sync_caches_direct(struct udf_strat_args *args)
{
       struct udf_mount *ump = args->ump;

       udf_mmc_synchronise_caches(ump);
}


static void
udf_discstrat_init_direct(struct udf_strat_args *args)
{
       struct udf_mount  *ump = args->ump;
       struct strat_private *priv = PRIV(ump);
       uint32_t lb_size;

       KASSERT(priv == NULL);
       ump->strategy_private = malloc(sizeof(struct strat_private),
               M_UDFTEMP, M_WAITOK);
       priv = ump->strategy_private;
       memset(priv, 0 , sizeof(struct strat_private));

       /*
        * Initialise pool for descriptors associated with nodes. This is done
        * in lb_size units though currently lb_size is dictated to be
        * sector_size.
        */
       memset(&priv->desc_pool, 0, sizeof(struct pool));

       lb_size = udf_rw32(ump->logical_vol->lb_size);
       pool_init(&priv->desc_pool, lb_size, 0, 0, 0, "udf_desc_pool", NULL,
           IPL_NONE);
}


static void
udf_discstrat_finish_direct(struct udf_strat_args *args)
{
       struct udf_mount *ump = args->ump;
       struct strat_private *priv = PRIV(ump);

       /* destroy our pool */
       pool_destroy(&priv->desc_pool);

       /* free our private space */
       free(ump->strategy_private, M_UDFTEMP);
       ump->strategy_private = NULL;
}

/* --------------------------------------------------------------------- */

struct udf_strategy udf_strat_direct =
{
       udf_getblank_nodedscr_direct,
       udf_free_nodedscr_direct,
       udf_read_nodedscr_direct,
       udf_write_nodedscr_direct,
       udf_queue_buf_direct,
       udf_sync_caches_direct,
       udf_discstrat_init_direct,
       udf_discstrat_finish_direct
};

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.