dev/dm/dm_pdev.c

/*        $NetBSD: dm_pdev.c,v 1.23 2021/08/21 22:23:33 andvar Exp $      */

/*
 * Copyright (c) 2008 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Adam Hamsik.
 *
 * 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/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: dm_pdev.c,v 1.23 2021/08/21 22:23:33 andvar Exp $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/disk.h>
#include <sys/fcntl.h>
#include <sys/kmem.h>
#include <sys/namei.h>

#include <dev/dkvar.h>

#include "dm.h"

static SLIST_HEAD(dm_pdevs, dm_pdev) dm_pdev_list;

static kmutex_t dm_pdev_mutex;

static dm_pdev_t *dm_pdev_alloc(const char *);
static int dm_pdev_rem(dm_pdev_t *);
static dm_pdev_t *dm_pdev_lookup_name(const char *);

/*
* Find used pdev with name == dm_pdev_name.
*/
dm_pdev_t *
dm_pdev_lookup_name(const char *dm_pdev_name)
{
          dm_pdev_t *dm_pdev;
          size_t dlen;
          size_t slen;

          KASSERT(dm_pdev_name != NULL);

          slen = strlen(dm_pdev_name);

          SLIST_FOREACH(dm_pdev, &dm_pdev_list, next_pdev) {
                    dlen = strlen(dm_pdev->name);

                    if (slen != dlen)
                              continue;

                    if (strncmp(dm_pdev_name, dm_pdev->name, slen) == 0)
                              return dm_pdev;
          }

          return NULL;
}

/*
 * Create entry for device with name dev_name and open vnode for it.
 * If entry already exists in global SLIST I will only increment
 * reference counter.
 */
dm_pdev_t *
dm_pdev_insert(const char *dev_name)
{
          struct pathbuf *dev_pb;
          dm_pdev_t *dmp;
          int error;

          KASSERT(dev_name != NULL);

          mutex_enter(&dm_pdev_mutex);
          dmp = dm_pdev_lookup_name(dev_name);

          if (dmp != NULL) {
                    dmp->ref_cnt++;
                    aprint_debug("%s: pdev %s already in tree\n",
                        __func__, dev_name);
                    mutex_exit(&dm_pdev_mutex);
                    return dmp;
          }

          if ((dmp = dm_pdev_alloc(dev_name)) == NULL) {
                    mutex_exit(&dm_pdev_mutex);
                    return NULL;
          }

          dev_pb = pathbuf_create(dev_name);
          if (dev_pb == NULL) {
                    aprint_debug("%s: pathbuf_create on device: %s failed!\n",
                        __func__, dev_name);
                    mutex_exit(&dm_pdev_mutex);
                    kmem_free(dmp, sizeof(dm_pdev_t));
                    return NULL;
          }
          error = vn_bdev_openpath(dev_pb, &dmp->pdev_vnode, curlwp);
          pathbuf_destroy(dev_pb);
          if (error) {
                    aprint_debug("%s: lookup on device: %s (error %d)\n",
                        __func__, dev_name, error);
                    mutex_exit(&dm_pdev_mutex);
                    kmem_free(dmp, sizeof(dm_pdev_t));
                    return NULL;
          }
          getdisksize(dmp->pdev_vnode, &dmp->pdev_numsec, &dmp->pdev_secsize);
          dmp->ref_cnt = 1;

          snprintf(dmp->udev_name, sizeof(dmp->udev_name), "%d:%d",
              major(dmp->pdev_vnode->v_rdev), minor(dmp->pdev_vnode->v_rdev));
          aprint_debug("%s: %s %s\n", __func__, dev_name, dmp->udev_name);

          SLIST_INSERT_HEAD(&dm_pdev_list, dmp, next_pdev);
          mutex_exit(&dm_pdev_mutex);

          return dmp;
}

/*
 * Initialize pdev subsystem.
 */
int
dm_pdev_init(void)
{

          SLIST_INIT(&dm_pdev_list);    /* initialize global pdev list */
          mutex_init(&dm_pdev_mutex, MUTEX_DEFAULT, IPL_NONE);

          return 0;
}

/*
 * Allocat new pdev structure if is not already present and
 * set name.
 */
static dm_pdev_t *
dm_pdev_alloc(const char *name)
{
          dm_pdev_t *dmp;

          dmp = kmem_zalloc(sizeof(*dmp), KM_SLEEP);
          strlcpy(dmp->name, name, sizeof(dmp->name));
          dmp->ref_cnt = 0;
          dmp->pdev_vnode = NULL;

          return dmp;
}

/*
 * Destroy allocated dm_pdev.
 */
static int
dm_pdev_rem(dm_pdev_t *dmp)
{

          KASSERT(dmp != NULL);

          if (dmp->pdev_vnode != NULL) {
                    int error = vn_close(dmp->pdev_vnode, FREAD | FWRITE, FSCRED);
                    if (error != 0) {
                              kmem_free(dmp, sizeof(*dmp));
                              return error;
                    }
          }
          kmem_free(dmp, sizeof(*dmp));

          return 0;
}

/*
 * Destroy all existing pdev's in device-mapper.
 */
int
dm_pdev_destroy(void)
{
          dm_pdev_t *dmp;

          mutex_enter(&dm_pdev_mutex);

          while ((dmp = SLIST_FIRST(&dm_pdev_list)) != NULL) {
                    SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
                    dm_pdev_rem(dmp);
          }
          KASSERT(SLIST_EMPTY(&dm_pdev_list));

          mutex_exit(&dm_pdev_mutex);

          mutex_destroy(&dm_pdev_mutex);
          return 0;
}

/*
 * This function is called from dm_dev_remove_ioctl.
 * When I'm removing device from list, I have to decrement
 * reference counter. If reference counter is 0 I will remove
 * dmp from global list and from device list to. And I will CLOSE
 * dmp vnode too.
 */

/*
 * Decrement pdev reference counter if 0 remove it.
 */
int
dm_pdev_decr(dm_pdev_t *dmp)
{

          KASSERT(dmp != NULL);
          /*
           * If this was last reference remove dmp from
           * global list also.
           */
          mutex_enter(&dm_pdev_mutex);

          if (--dmp->ref_cnt == 0) {
                    SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
                    mutex_exit(&dm_pdev_mutex);
                    dm_pdev_rem(dmp);
                    return 0;
          }

          mutex_exit(&dm_pdev_mutex);
          return 0;
}

#if 0
static int
dm_pdev_dump_list(void)
{
          dm_pdev_t *dmp;

          aprint_verbose("Dumping dm_pdev_list\n");

          SLIST_FOREACH(dmp, &dm_pdev_list, next_pdev) {
                    aprint_verbose("dm_pdev_name %s ref_cnt %d list_rf_cnt %d\n",
                    dmp->name, dmp->ref_cnt, dmp->list_ref_cnt);
          }

          return 0;
}
#endif