/*      $NetBSD: rf_compat50.c,v 1.13 2019/12/15 16:48:27 tsutsui Exp $ */

/*-
* Copyright (c) 2009 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Christos Zoulas.
*
* 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 NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 FOUNDATION OR CONTRIBUTORS
* 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/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/module.h>

#include <sys/compat_stub.h>

#include <dev/raidframe/raidframeio.h>
#include <dev/raidframe/raidframevar.h>

#include "rf_raid.h"
#include "rf_compat50.h"
#include "rf_debugMem.h"

typedef struct RF_Config50_s {
       RF_RowCol_t             numRow, numCol, numSpare;
       int32_t                 devs[RF_MAXROW][RF_MAXCOL];
       char                    devnames[RF_MAXROW][RF_MAXCOL][50];
       int32_t                 spare_devs[RF_MAXSPARE];
       char                    spare_names[RF_MAXSPARE][50];
       RF_SectorNum_t          sectPerSU;
       RF_StripeNum_t          SUsPerPU;
       RF_StripeNum_t          SUsPerRU;
       RF_ParityConfig_t       parityConfig;
       RF_DiskQueueType_t      diskQueueType;
       char                    maxOutstandingDiskReqs;
       char                    debugVars[RF_MAXDBGV][50];
       unsigned int            layoutSpecificSize;
       void                   *layoutSpecific;
       int                     force;
} RF_Config50_t;

typedef struct RF_RaidDisk50_s {
       char             devname[56];
       RF_DiskStatus_t  status;
       RF_RowCol_t      spareRow;
       RF_RowCol_t      spareCol;
       RF_SectorCount_t numBlocks;
       int              blockSize;
       RF_SectorCount_t partitionSize;
       int              auto_configured;
       int32_t          dev;
} RF_RaidDisk50_t;

typedef struct RF_DeviceConfig50_s {
       u_int                   rows;
       u_int                   cols;
       u_int                   maxqdepth;
       int                     ndevs;
       RF_RaidDisk50_t         devs[RF_MAX_DISKS];
       u_int                   nspares;
       RF_RaidDisk50_t         spares[RF_MAX_DISKS];
} RF_DeviceConfig50_t;

static void
rf_disk_to_disk50(RF_RaidDisk50_t *d50, const RF_RaidDisk_t *d)
{
       memcpy(d50->devname, d->devname, sizeof(d50->devname));
       d50->status = d->status;
       d50->spareRow = 0;
       d50->spareCol = d->spareCol;
       d50->numBlocks = d->numBlocks;
       d50->blockSize = d->blockSize;
       d50->partitionSize = d->partitionSize;
       d50->auto_configured = d->auto_configured;
       d50->dev = d->dev;
}

static int
rf_config50(struct raid_softc *rs, void *data)
{
       RF_Config50_t *u50_cfg, *k50_cfg;
       RF_Config_t *k_cfg;
       RF_Raid_t *raidPtr = rf_get_raid(rs);
       size_t i, j;
       int error;

       if (raidPtr->valid) {
               /* There is a valid RAID set running on this unit! */
               printf("raid%d: Device already configured!\n", rf_get_unit(rs));
               return EINVAL;
       }

       /* copy-in the configuration information */
       /* data points to a pointer to the configuration structure */

       u50_cfg = *((RF_Config50_t **) data);
       k50_cfg = RF_Malloc(sizeof(*k50_cfg));
       if (k50_cfg == NULL)
               return ENOMEM;

       error = copyin(u50_cfg, k50_cfg, sizeof(*k50_cfg));
       if (error) {
               RF_Free(k50_cfg, sizeof(*k50_cfg));
               return error;
       }
       k_cfg = RF_Malloc(sizeof(*k_cfg));
       if (k_cfg == NULL) {
               RF_Free(k50_cfg, sizeof(*k50_cfg));
               return ENOMEM;
       }

       k_cfg->numCol = k50_cfg->numCol;
       k_cfg->numSpare = k50_cfg->numSpare;

       for (i = 0; i < RF_MAXROW; i++)
               for (j = 0; j < RF_MAXCOL; j++)
                       k_cfg->devs[i][j] = k50_cfg->devs[i][j];

       memcpy(k_cfg->devnames, k50_cfg->devnames,
           sizeof(k_cfg->devnames));

       for (i = 0; i < RF_MAXSPARE; i++)
               k_cfg->spare_devs[i] = k50_cfg->spare_devs[i];

       memcpy(k_cfg->spare_names, k50_cfg->spare_names,
           sizeof(k_cfg->spare_names));

       k_cfg->sectPerSU = k50_cfg->sectPerSU;
       k_cfg->SUsPerPU = k50_cfg->SUsPerPU;
       k_cfg->SUsPerRU = k50_cfg->SUsPerRU;
       k_cfg->parityConfig = k50_cfg->parityConfig;

       memcpy(k_cfg->diskQueueType, k50_cfg->diskQueueType,
           sizeof(k_cfg->diskQueueType));

       k_cfg->maxOutstandingDiskReqs = k50_cfg->maxOutstandingDiskReqs;

       memcpy(k_cfg->debugVars, k50_cfg->debugVars,
           sizeof(k_cfg->debugVars));

       k_cfg->layoutSpecificSize = k50_cfg->layoutSpecificSize;
       k_cfg->layoutSpecific = k50_cfg->layoutSpecific;
       k_cfg->force = k50_cfg->force;

       RF_Free(k50_cfg, sizeof(*k50_cfg));
       return rf_construct(rs, k_cfg);
}

static int
rf_get_info50(RF_Raid_t *raidPtr, void *data)
{
       RF_DeviceConfig50_t **ucfgp = data, *d_cfg;
       size_t i, j;
       int error;

       if (!raidPtr->valid)
               return ENODEV;

       d_cfg = RF_Malloc(sizeof(*d_cfg));

       if (d_cfg == NULL)
               return ENOMEM;

       d_cfg->rows = 1; /* there is only 1 row now */
       d_cfg->cols = raidPtr->numCol;
       d_cfg->ndevs = raidPtr->numCol;
       if (d_cfg->ndevs >= RF_MAX_DISKS) {
               error = ENOMEM;
               goto out;
       }

       d_cfg->nspares = raidPtr->numSpare;
       if (d_cfg->nspares >= RF_MAX_DISKS) {
               error = ENOMEM;
               goto out;
       }

       d_cfg->maxqdepth = raidPtr->maxQueueDepth;
       for (j = 0; j < d_cfg->cols; j++)
               rf_disk_to_disk50(&d_cfg->devs[j], &raidPtr->Disks[j]);

       for (j = d_cfg->cols, i = 0; i < d_cfg->nspares; i++, j++)
               rf_disk_to_disk50(&d_cfg->spares[i], &raidPtr->Disks[j]);

       error = copyout(d_cfg, *ucfgp, sizeof(**ucfgp));

out:
       RF_Free(d_cfg, sizeof(*d_cfg));
       return error;
}

static int
raidframe_ioctl_50(struct raid_softc *rs, u_long cmd, void *data)
{
       RF_Raid_t *raidPtr = rf_get_raid(rs);

       switch (cmd) {
       case RAIDFRAME_GET_INFO50:
               if (!rf_inited(rs))
                       return ENXIO;
               return rf_get_info50(raidPtr, data);

       case RAIDFRAME_CONFIGURE50:
               return rf_config50(rs, data);
       default:
               return EPASSTHROUGH;
       }
}

static void
raidframe_50_init(void)
{

       MODULE_HOOK_SET(raidframe_ioctl_50_hook, raidframe_ioctl_50);
}

static void
raidframe_50_fini(void)
{

       MODULE_HOOK_UNSET(raidframe_ioctl_50_hook);
}

MODULE(MODULE_CLASS_EXEC, compat_raid_50, "raid,compat_50,compat_raid_80");

static int
compat_raid_50_modcmd(modcmd_t cmd, void *arg)
{

       switch (cmd) {
       case MODULE_CMD_INIT:
               raidframe_50_init();
               return 0;
       case MODULE_CMD_FINI:
               raidframe_50_fini();
               return 0;
       default:
               return ENOTTY;
       }
}

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.