Annotation of src/sys/dev/dm/dm_ioctl.c, revision 1.37

1.37    ! tkusumi     1: /* $NetBSD: dm_ioctl.c,v 1.36 2019/12/03 15:47:38 tkusumi Exp $      */
1.2       haad        2: 
                      3: /*
                      4:  * Copyright (c) 2008 The NetBSD Foundation, Inc.
                      5:  * All rights reserved.
                      6:  *
                      7:  * This code is derived from software contributed to The NetBSD Foundation
                      8:  * by Adam Hamsik.
                      9:  *
                     10:  * Redistribution and use in source and binary forms, with or without
                     11:  * modification, are permitted provided that the following conditions
                     12:  * are met:
                     13:  * 1. Redistributions of source code must retain the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer.
                     15:  * 2. Redistributions in binary form must reproduce the above copyright
                     16:  *    notice, this list of conditions and the following disclaimer in the
                     17:  *    documentation and/or other materials provided with the distribution.
                     18:  *
                     19:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
                     20:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
                     21:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                     22:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
                     23:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                     24:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                     25:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                     26:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                     27:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                     28:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                     29:  * POSSIBILITY OF SUCH DAMAGE.
                     30:  */
1.32      christos   31: #include <sys/cdefs.h>
1.37    ! tkusumi    32: __KERNEL_RCSID(0, "$NetBSD: dm_ioctl.c,v 1.36 2019/12/03 15:47:38 tkusumi Exp $");
1.2       haad       33: 
                     34: /*
                     35:  * Locking is used to synchronise between ioctl calls and between dm_table's
                     36:  * users.
                     37:  *
                     38:  * ioctl locking:
                     39:  * Simple reference counting, to count users of device will be used routines
                     40:  * dm_dev_busy/dm_dev_unbusy are used for that.
                     41:  * dm_dev_lookup/dm_dev_rem call dm_dev_busy before return(caller is therefore
                     42:  * holder of reference_counter last).
                     43:  *
                     44:  * ioctl routines which change/remove dm_dev parameters must wait on
                     45:  * dm_dev::dev_cv and when last user will call dm_dev_unbusy they will wake
                     46:  * up them.
                     47:  *
                     48:  * table_head locking:
1.20      haad       49:  * To access table entries dm_table_* routines must be used.
1.2       haad       50:  *
                     51:  * dm_table_get_entry will increment table users reference
1.22      haad       52:  * counter. It will return active or inactive table depends
1.2       haad       53:  * on uint8_t argument.
                     54:  *
                     55:  * dm_table_release must be called for every table_entry from
                     56:  * dm_table_get_entry. Between these to calls tables can'tbe switched
1.20      haad       57:  * or destroyed.
1.2       haad       58:  *
                     59:  * dm_table_head_init initialize talbe_entries SLISTS and io_cv.
                     60:  *
                     61:  * dm_table_head_destroy destroy cv.
                     62:  *
                     63:  * There are two types of users for dm_table_head first type will
                     64:  * only read list and try to do anything with it e.g. dmstrategy,
                     65:  * dm_table_size etc. There is another user for table_head which wants
                     66:  * to change table lists e.g. dm_dev_resume_ioctl, dm_dev_remove_ioctl,
                     67:  * dm_table_clear_ioctl.
1.20      haad       68:  *
1.2       haad       69:  * NOTE: It is not allowed to call dm_table_destroy, dm_table_switch_tables
                     70:  *       with hold table reference counter. Table reference counter is hold
                     71:  *       after calling dm_table_get_entry routine. After calling this
                     72:  *       function user must call dm_table_release before any writer table
                     73:  *       operation.
                     74:  *
                     75:  * Example: dm_table_get_entry
                     76:  *          dm_table_destroy/dm_table_switch_tables
                     77:  * This exaple will lead to deadlock situation because after dm_table_get_entry
                     78:  * table reference counter is != 0 and dm_table_destroy have to wait on cv until
                     79:  * reference counter is 0.
                     80:  *
                     81:  */
                     82: 
                     83: #include <sys/types.h>
                     84: #include <sys/param.h>
                     85: 
1.19      haad       86: #include <sys/device.h>
1.6       haad       87: #include <sys/disk.h>
1.2       haad       88: #include <sys/disklabel.h>
                     89: #include <sys/kmem.h>
                     90: #include <sys/malloc.h>
                     91: 
                     92: #include <machine/int_fmtio.h>
                     93: 
                     94: #include "netbsd-dm.h"
                     95: #include "dm.h"
                     96: 
1.23      haad       97: static uint32_t sc_minor_num;
1.10      haad       98: extern const struct dkdriver dmdkdriver;
1.24      haad       99: uint32_t dm_dev_counter;
1.2       haad      100: 
1.19      haad      101: /* Generic cf_data for device-mapper driver */
                    102: static struct cfdata dm_cfdata = {
                    103:        .cf_name = "dm",
                    104:        .cf_atname = "dm",
                    105:        .cf_fstate = FSTATE_STAR,
                    106:        .cf_unit = 0
                    107: };
1.2       haad      108: #define DM_REMOVE_FLAG(flag, name) do {                                        \
                    109:                prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
                    110:                flag &= ~name;                                          \
                    111:                prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
1.20      haad      112: } while (/*CONSTCOND*/0)
1.2       haad      113: 
                    114: #define DM_ADD_FLAG(flag, name) do {                                   \
                    115:                prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
                    116:                flag |= name;                                           \
                    117:                prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
1.20      haad      118: } while (/*CONSTCOND*/0)
1.2       haad      119: 
                    120: static int dm_dbg_print_flags(int);
                    121: 
                    122: /*
                    123:  * Print flags sent to the kernel from libevmapper.
                    124:  */
                    125: static int
                    126: dm_dbg_print_flags(int flags)
                    127: {
1.20      haad      128:        aprint_debug("dbg_print --- %d\n", flags);
                    129: 
1.2       haad      130:        if (flags & DM_READONLY_FLAG)
                    131:                aprint_debug("dbg_flags: DM_READONLY_FLAG set In/Out\n");
                    132: 
                    133:        if (flags & DM_SUSPEND_FLAG)
                    134:                aprint_debug("dbg_flags: DM_SUSPEND_FLAG set In/Out \n");
                    135: 
                    136:        if (flags & DM_PERSISTENT_DEV_FLAG)
                    137:                aprint_debug("db_flags: DM_PERSISTENT_DEV_FLAG set In\n");
                    138: 
                    139:        if (flags & DM_STATUS_TABLE_FLAG)
                    140:                aprint_debug("dbg_flags: DM_STATUS_TABLE_FLAG set In\n");
                    141: 
                    142:        if (flags & DM_ACTIVE_PRESENT_FLAG)
                    143:                aprint_debug("dbg_flags: DM_ACTIVE_PRESENT_FLAG set Out\n");
                    144: 
                    145:        if (flags & DM_INACTIVE_PRESENT_FLAG)
                    146:                aprint_debug("dbg_flags: DM_INACTIVE_PRESENT_FLAG set Out\n");
                    147: 
                    148:        if (flags & DM_BUFFER_FULL_FLAG)
                    149:                aprint_debug("dbg_flags: DM_BUFFER_FULL_FLAG set Out\n");
                    150: 
                    151:        if (flags & DM_SKIP_BDGET_FLAG)
                    152:                aprint_debug("dbg_flags: DM_SKIP_BDGET_FLAG set In\n");
                    153: 
                    154:        if (flags & DM_SKIP_LOCKFS_FLAG)
                    155:                aprint_debug("dbg_flags: DM_SKIP_LOCKFS_FLAG set In\n");
                    156: 
                    157:        if (flags & DM_NOFLUSH_FLAG)
                    158:                aprint_debug("dbg_flags: DM_NOFLUSH_FLAG set In\n");
1.20      haad      159: 
1.2       haad      160:        return 0;
                    161: }
1.32      christos  162: 
1.2       haad      163: /*
                    164:  * Get version ioctl call I do it as default therefore this
                    165:  * function is unused now.
                    166:  */
                    167: int
                    168: dm_get_version_ioctl(prop_dictionary_t dm_dict)
                    169: {
1.20      haad      170: 
1.2       haad      171:        return 0;
                    172: }
1.32      christos  173: 
1.2       haad      174: /*
                    175:  * Get list of all available targets from global
                    176:  * target list and sent them back to libdevmapper.
                    177:  */
                    178: int
                    179: dm_list_versions_ioctl(prop_dictionary_t dm_dict)
                    180: {
                    181:        prop_array_t target_list;
                    182:        uint32_t flags;
                    183: 
                    184:        flags = 0;
                    185: 
                    186:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.20      haad      187: 
1.2       haad      188:        dm_dbg_print_flags(flags);
                    189:        target_list = dm_target_prop_list();
                    190: 
                    191:        prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list);
1.20      haad      192:        prop_object_release(target_list);
1.2       haad      193: 
                    194:        return 0;
                    195: }
1.32      christos  196: 
1.2       haad      197: /*
                    198:  * Create in-kernel entry for device. Device attributes such as name, uuid are
                    199:  * taken from proplib dictionary.
                    200:  *
                    201:  */
                    202: int
                    203: dm_dev_create_ioctl(prop_dictionary_t dm_dict)
                    204: {
                    205:        dm_dev_t *dmv;
                    206:        const char *name, *uuid;
1.29      justin    207:        int r;
                    208:        uint32_t flags;
1.19      haad      209:        device_t devt;
1.20      haad      210: 
1.2       haad      211:        r = 0;
                    212:        flags = 0;
1.20      haad      213:        name = NULL;
1.2       haad      214:        uuid = NULL;
                    215: 
                    216:        /* Get needed values from dictionary. */
                    217:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    218:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    219:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.20      haad      220: 
1.2       haad      221:        dm_dbg_print_flags(flags);
                    222: 
                    223:        /* Lookup name and uuid if device already exist quit. */
                    224:        if ((dmv = dm_dev_lookup(name, uuid, -1)) != NULL) {
1.20      haad      225:                DM_ADD_FLAG(flags, DM_EXISTS_FLAG);     /* Device already exists */
1.2       haad      226:                dm_dev_unbusy(dmv);
                    227:                return EEXIST;
                    228:        }
1.19      haad      229:        if ((devt = config_attach_pseudo(&dm_cfdata)) == NULL) {
                    230:                aprint_error("Unable to attach pseudo device dm/%s\n", name);
                    231:                return (ENOMEM);
                    232:        }
1.2       haad      233:        if ((dmv = dm_dev_alloc()) == NULL)
                    234:                return ENOMEM;
1.19      haad      235: 
1.2       haad      236:        if (uuid)
                    237:                strncpy(dmv->uuid, uuid, DM_UUID_LEN);
1.20      haad      238:        else
1.2       haad      239:                dmv->uuid[0] = '\0';
1.20      haad      240: 
1.2       haad      241:        if (name)
                    242:                strlcpy(dmv->name, name, DM_NAME_LEN);
                    243: 
1.23      haad      244:        dmv->minor = (uint64_t)atomic_inc_32_nv(&sc_minor_num);
1.20      haad      245:        dmv->flags = 0;         /* device flags are set when needed */
1.2       haad      246:        dmv->ref_cnt = 0;
                    247:        dmv->event_nr = 0;
1.19      haad      248:        dmv->devt = devt;
1.20      haad      249: 
1.19      haad      250:        dm_table_head_init(&dmv->table_head);
                    251: 
1.2       haad      252:        mutex_init(&dmv->dev_mtx, MUTEX_DEFAULT, IPL_NONE);
1.18      haad      253:        mutex_init(&dmv->diskp_mtx, MUTEX_DEFAULT, IPL_NONE);
1.2       haad      254:        cv_init(&dmv->dev_cv, "dm_dev");
                    255: 
                    256:        if (flags & DM_READONLY_FLAG)
                    257:                dmv->flags |= DM_READONLY_FLAG;
                    258: 
                    259:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
1.6       haad      260: 
1.10      haad      261:        disk_init(dmv->diskp, dmv->name, &dmdkdriver);
                    262:        disk_attach(dmv->diskp);
1.13      haad      263: 
                    264:        dmv->diskp->dk_info = NULL;
1.20      haad      265: 
                    266:        if ((r = dm_dev_insert(dmv)) != 0)
1.2       haad      267:                dm_dev_free(dmv);
1.20      haad      268: 
1.2       haad      269:        DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
                    270:        DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
1.6       haad      271: 
                    272:        /* Increment device counter After creating device */
1.24      haad      273:        atomic_inc_32(&dm_dev_counter);
1.20      haad      274: 
1.2       haad      275:        return r;
                    276: }
1.32      christos  277: 
1.2       haad      278: /*
                    279:  * Get list of created device-mapper devices fromglobal list and
                    280:  * send it to kernel.
                    281:  *
                    282:  * Output dictionary:
                    283:  *
                    284:  * <key>cmd_data</key>
                    285:  *  <array>
                    286:  *   <dict>
                    287:  *    <key>name<key>
                    288:  *    <string>...</string>
                    289:  *
                    290:  *    <key>dev</key>
                    291:  *    <integer>...</integer>
                    292:  *   </dict>
                    293:  *  </array>
1.20      haad      294:  *
1.2       haad      295:  */
                    296: int
                    297: dm_dev_list_ioctl(prop_dictionary_t dm_dict)
                    298: {
                    299:        prop_array_t dev_list;
                    300:        uint32_t flags;
1.20      haad      301: 
1.2       haad      302:        flags = 0;
1.20      haad      303: 
1.2       haad      304:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.20      haad      305: 
1.2       haad      306:        dm_dbg_print_flags(flags);
1.20      haad      307: 
1.2       haad      308:        dev_list = dm_dev_prop_list();
                    309: 
                    310:        prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, dev_list);
                    311:        prop_object_release(dev_list);
1.20      haad      312: 
1.2       haad      313:        return 0;
                    314: }
1.32      christos  315: 
1.2       haad      316: /*
                    317:  * Rename selected devices old name is in struct dm_ioctl.
                    318:  * newname is taken from dictionary
                    319:  *
                    320:  * <key>cmd_data</key>
                    321:  *  <array>
                    322:  *   <string>...</string>
                    323:  *  </array>
                    324:  */
                    325: int
                    326: dm_dev_rename_ioctl(prop_dictionary_t dm_dict)
                    327: {
                    328:        prop_array_t cmd_array;
                    329:        dm_dev_t *dmv;
1.20      haad      330: 
1.2       haad      331:        const char *name, *uuid, *n_name;
                    332:        uint32_t flags, minor;
                    333: 
                    334:        name = NULL;
                    335:        uuid = NULL;
                    336:        minor = 0;
1.20      haad      337: 
1.2       haad      338:        /* Get needed values from dictionary. */
                    339:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    340:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    341:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    342:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
                    343: 
                    344:        dm_dbg_print_flags(flags);
1.20      haad      345: 
1.2       haad      346:        cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
                    347: 
                    348:        prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
1.20      haad      349: 
1.2       haad      350:        if (strlen(n_name) + 1 > DM_NAME_LEN)
                    351:                return EINVAL;
1.20      haad      352: 
1.2       haad      353:        if ((dmv = dm_dev_rem(name, uuid, minor)) == NULL) {
                    354:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    355:                return ENOENT;
                    356:        }
                    357:        /* change device name */
1.20      haad      358:        /*
                    359:         * XXX How to deal with this change, name only used in
                    360:         * dm_dev_routines, should I add dm_dev_change_name which will run
                    361:         * under the dm_dev_list mutex ?
1.2       haad      362:         */
                    363:        strlcpy(dmv->name, n_name, DM_NAME_LEN);
1.20      haad      364: 
1.2       haad      365:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
                    366:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
                    367:        prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
                    368: 
                    369:        dm_dev_insert(dmv);
1.20      haad      370: 
1.2       haad      371:        return 0;
                    372: }
1.32      christos  373: 
1.2       haad      374: /*
                    375:  * Remove device from global list I have to remove active
                    376:  * and inactive tables first.
                    377:  */
                    378: int
                    379: dm_dev_remove_ioctl(prop_dictionary_t dm_dict)
                    380: {
                    381:        dm_dev_t *dmv;
                    382:        const char *name, *uuid;
                    383:        uint32_t flags, minor;
1.19      haad      384:        device_t devt;
1.20      haad      385: 
1.2       haad      386:        flags = 0;
                    387:        name = NULL;
                    388:        uuid = NULL;
1.20      haad      389: 
1.2       haad      390:        /* Get needed values from dictionary. */
                    391:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    392:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    393:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    394:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
1.20      haad      395: 
1.2       haad      396:        dm_dbg_print_flags(flags);
1.19      haad      397: 
1.20      haad      398:        /*
                    399:         * This seems as hack to me, probably use routine dm_dev_get_devt to
                    400:         * atomicaly get devt from device.
                    401:         */
1.19      haad      402:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      403:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    404:                return ENOENT;
                    405:        }
1.19      haad      406:        devt = dmv->devt;
1.2       haad      407: 
1.19      haad      408:        dm_dev_unbusy(dmv);
1.20      haad      409: 
                    410:        /*
                    411:         * This will call dm_detach routine which will actually removes
                    412:         * device.
                    413:         */
1.19      haad      414:        return config_detach(devt, DETACH_QUIET);
1.2       haad      415: }
1.32      christos  416: 
1.2       haad      417: /*
                    418:  * Return actual state of device to libdevmapper.
                    419:  */
                    420: int
                    421: dm_dev_status_ioctl(prop_dictionary_t dm_dict)
                    422: {
                    423:        dm_dev_t *dmv;
                    424:        const char *name, *uuid;
                    425:        uint32_t flags, j, minor;
1.20      haad      426: 
1.2       haad      427:        name = NULL;
                    428:        uuid = NULL;
                    429:        flags = 0;
                    430:        j = 0;
1.20      haad      431: 
1.2       haad      432:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    433:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    434:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    435:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
1.20      haad      436: 
1.2       haad      437:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
                    438:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    439:                return ENOENT;
                    440:        }
1.20      haad      441:        dm_dbg_print_flags(dmv->flags);
1.2       haad      442: 
                    443:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
                    444:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
                    445:        prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
                    446: 
                    447:        if (dmv->flags & DM_SUSPEND_FLAG)
                    448:                DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
                    449: 
1.20      haad      450:        /*
                    451:         * Add status flags for tables I have to check both active and
                    452:         * inactive tables.
                    453:         */
1.37    ! tkusumi   454:        if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE)))
1.2       haad      455:                DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
1.37    ! tkusumi   456:        else
1.2       haad      457:                DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
1.20      haad      458: 
1.2       haad      459:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j);
1.20      haad      460: 
1.2       haad      461:        if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
                    462:                DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
                    463:        else
                    464:                DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
                    465: 
                    466:        dm_dev_unbusy(dmv);
1.20      haad      467: 
1.2       haad      468:        return 0;
                    469: }
1.32      christos  470: 
1.2       haad      471: /*
                    472:  * Set only flag to suggest that device is suspended. This call is
                    473:  * not supported in NetBSD.
                    474:  *
                    475:  */
                    476: int
                    477: dm_dev_suspend_ioctl(prop_dictionary_t dm_dict)
                    478: {
                    479:        dm_dev_t *dmv;
                    480:        const char *name, *uuid;
                    481:        uint32_t flags, minor;
1.20      haad      482: 
1.2       haad      483:        name = NULL;
                    484:        uuid = NULL;
                    485:        flags = 0;
1.20      haad      486: 
1.2       haad      487:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    488:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    489:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    490:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
1.20      haad      491: 
                    492:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      493:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    494:                return ENOENT;
                    495:        }
                    496:        atomic_or_32(&dmv->flags, DM_SUSPEND_FLAG);
1.20      haad      497: 
1.2       haad      498:        dm_dbg_print_flags(dmv->flags);
1.20      haad      499: 
1.2       haad      500:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
                    501:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags);
                    502:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
1.20      haad      503: 
1.2       haad      504:        dm_dev_unbusy(dmv);
1.20      haad      505: 
1.2       haad      506:        /* Add flags to dictionary flag after dmv -> dict copy */
1.20      haad      507:        DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
                    508: 
1.2       haad      509:        return 0;
                    510: }
1.32      christos  511: 
1.2       haad      512: /*
                    513:  * Simulate Linux behaviour better and switch tables here and not in
1.20      haad      514:  * dm_table_load_ioctl.
1.2       haad      515:  */
                    516: int
                    517: dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
                    518: {
                    519:        dm_dev_t *dmv;
                    520:        const char *name, *uuid;
                    521:        uint32_t flags, minor;
                    522: 
                    523:        name = NULL;
                    524:        uuid = NULL;
                    525:        flags = 0;
1.20      haad      526: 
                    527:        /*
                    528:         * char *xml; xml = prop_dictionary_externalize(dm_dict);
                    529:         * printf("%s\n",xml);
                    530:         */
                    531: 
1.2       haad      532:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    533:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    534:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    535:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
1.20      haad      536: 
1.2       haad      537:        /* Remove device from global device list */
1.20      haad      538:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      539:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    540:                return ENOENT;
                    541:        }
1.33      mlelstv   542: 
                    543:        /* Make inactive table active, if it exists */
                    544:        if (dmv->flags & DM_INACTIVE_PRESENT_FLAG)
                    545:                dm_table_switch_tables(&dmv->table_head);
                    546: 
1.2       haad      547:        atomic_and_32(&dmv->flags, ~(DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG));
                    548:        atomic_or_32(&dmv->flags, DM_ACTIVE_PRESENT_FLAG);
1.20      haad      549: 
                    550:        DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
1.2       haad      551: 
1.13      haad      552:        dmgetproperties(dmv->diskp, &dmv->table_head);
1.20      haad      553: 
1.2       haad      554:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
1.16      haad      555:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
1.2       haad      556:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
                    557: 
                    558:        dm_dev_unbusy(dmv);
                    559: 
                    560:        /* Destroy inactive table after resume. */
                    561:        dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
1.20      haad      562: 
1.2       haad      563:        return 0;
                    564: }
1.32      christos  565: 
1.2       haad      566: /*
                    567:  * Table management routines
                    568:  * lvm2tools doens't send name/uuid to kernel with table
                    569:  * for lookup I have to use minor number.
                    570:  */
                    571: 
                    572: /*
                    573:  * Remove inactive table from device. Routines which work's with inactive tables
                    574:  * doesn't need to synchronise with dmstrategy. They can synchronise themselves with mutex?.
                    575:  *
                    576:  */
                    577: int
                    578: dm_table_clear_ioctl(prop_dictionary_t dm_dict)
                    579: {
                    580:        dm_dev_t *dmv;
                    581:        const char *name, *uuid;
                    582:        uint32_t flags, minor;
                    583: 
1.20      haad      584:        dmv = NULL;
1.2       haad      585:        name = NULL;
                    586:        uuid = NULL;
                    587:        flags = 0;
                    588:        minor = 0;
1.20      haad      589: 
1.2       haad      590:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    591:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    592:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    593:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
1.20      haad      594: 
1.2       haad      595:        aprint_debug("Clearing inactive table from device: %s--%s\n",
                    596:            name, uuid);
1.20      haad      597: 
                    598:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      599:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    600:                return ENOENT;
                    601:        }
                    602:        /* Select unused table */
                    603:        dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
                    604: 
                    605:        atomic_and_32(&dmv->flags, ~DM_INACTIVE_PRESENT_FLAG);
                    606: 
                    607:        dm_dev_unbusy(dmv);
1.20      haad      608: 
1.2       haad      609:        return 0;
                    610: }
1.32      christos  611: 
1.2       haad      612: /*
                    613:  * Get list of physical devices for active table.
                    614:  * Get dev_t from pdev vnode and insert it into cmd_array.
                    615:  *
                    616:  * XXX. This function is called from lvm2tools to get information
1.20      haad      617:  *      about physical devices, too e.g. during vgcreate.
1.2       haad      618:  */
                    619: int
                    620: dm_table_deps_ioctl(prop_dictionary_t dm_dict)
                    621: {
                    622:        dm_dev_t *dmv;
                    623:        dm_table_t *tbl;
                    624:        dm_table_entry_t *table_en;
                    625: 
                    626:        prop_array_t cmd_array;
                    627:        const char *name, *uuid;
                    628:        uint32_t flags, minor;
1.17      haad      629: 
                    630:        int table_type;
1.2       haad      631: 
                    632:        name = NULL;
                    633:        uuid = NULL;
1.20      haad      634:        dmv = NULL;
1.2       haad      635:        flags = 0;
1.20      haad      636: 
1.2       haad      637:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    638:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    639:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    640:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
                    641: 
                    642:        /* create array for dev_t's */
                    643:        cmd_array = prop_array_create();
                    644: 
1.20      haad      645:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      646:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    647:                return ENOENT;
                    648:        }
                    649:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
                    650:        prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name);
                    651:        prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
1.20      haad      652: 
1.2       haad      653:        aprint_debug("Getting table deps for device: %s\n", dmv->name);
                    654: 
1.20      haad      655:        /*
                    656:         * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
                    657:         * INACTIVE TABLE
                    658:         */
1.17      haad      659:        if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
                    660:                table_type = DM_TABLE_INACTIVE;
                    661:        else
                    662:                table_type = DM_TABLE_ACTIVE;
1.20      haad      663: 
1.17      haad      664:        tbl = dm_table_get_entry(&dmv->table_head, table_type);
1.2       haad      665: 
                    666:        SLIST_FOREACH(table_en, tbl, next)
1.37    ! tkusumi   667:                table_en->target->deps(table_en, cmd_array);
1.2       haad      668: 
1.17      haad      669:        dm_table_release(&dmv->table_head, table_type);
1.2       haad      670:        dm_dev_unbusy(dmv);
1.20      haad      671: 
1.2       haad      672:        prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
                    673:        prop_object_release(cmd_array);
1.20      haad      674: 
1.2       haad      675:        return 0;
                    676: }
1.32      christos  677: 
1.2       haad      678: /*
                    679:  * Load new table/tables to device.
                    680:  * Call apropriate target init routine open all physical pdev's and
                    681:  * link them to device. For other targets mirror, strip, snapshot
                    682:  * etc. also add dependency devices to upcalls list.
                    683:  *
                    684:  * Load table to inactive slot table are switched in dm_device_resume_ioctl.
                    685:  * This simulates Linux behaviour better there should not be any difference.
                    686:  *
                    687:  */
                    688: int
                    689: dm_table_load_ioctl(prop_dictionary_t dm_dict)
                    690: {
                    691:        dm_dev_t *dmv;
                    692:        dm_table_entry_t *table_en, *last_table;
1.20      haad      693:        dm_table_t *tbl;
1.2       haad      694:        dm_target_t *target;
                    695: 
                    696:        prop_object_iterator_t iter;
                    697:        prop_array_t cmd_array;
1.15      haad      698:        prop_dictionary_t target_dict;
1.20      haad      699: 
1.2       haad      700:        const char *name, *uuid, *type;
                    701:        uint32_t flags, ret, minor;
1.15      haad      702:        char *str;
                    703: 
1.2       haad      704:        ret = 0;
                    705:        flags = 0;
                    706:        name = NULL;
                    707:        uuid = NULL;
                    708:        dmv = NULL;
                    709:        last_table = NULL;
1.15      haad      710:        str = NULL;
1.2       haad      711: 
1.20      haad      712:        /*
                    713:         * char *xml; xml = prop_dictionary_externalize(dm_dict);
                    714:         * printf("%s\n",xml);
                    715:         */
                    716: 
1.2       haad      717:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    718:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    719:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    720:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
1.20      haad      721: 
1.2       haad      722:        cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
                    723:        iter = prop_array_iterator(cmd_array);
1.20      haad      724:        dm_dbg_print_flags(flags);
                    725: 
                    726:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      727:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
1.28      mlelstv   728:                prop_object_iterator_release(iter);
1.2       haad      729:                return ENOENT;
                    730:        }
1.7       haad      731:        aprint_debug("Loading table to device: %s--%d\n", name,
                    732:            dmv->table_head.cur_active_table);
1.20      haad      733: 
1.2       haad      734:        /*
                    735:         * I have to check if this table slot is not used by another table list.
                    736:         * if it is used I should free them.
                    737:         */
                    738:        if (dmv->flags & DM_INACTIVE_PRESENT_FLAG)
                    739:                dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
                    740: 
                    741:        dm_dbg_print_flags(dmv->flags);
                    742:        tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_INACTIVE);
1.20      haad      743: 
1.2       haad      744:        aprint_debug("dmv->name = %s\n", dmv->name);
1.20      haad      745: 
1.2       haad      746:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
                    747: 
1.20      haad      748:        while ((target_dict = prop_object_iterator_next(iter)) != NULL) {
1.2       haad      749:                prop_dictionary_get_cstring_nocopy(target_dict,
                    750:                    DM_TABLE_TYPE, &type);
                    751:                /*
                    752:                 * If we want to deny table with 2 or more different
                    753:                 * target we should do it here
                    754:                 */
1.7       haad      755:                if (((target = dm_target_lookup(type)) == NULL) &&
                    756:                    ((target = dm_target_autoload(type)) == NULL)) {
1.8       haad      757:                        dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
1.7       haad      758:                        dm_dev_unbusy(dmv);
1.28      mlelstv   759:                        prop_object_iterator_release(iter);
1.2       haad      760:                        return ENOENT;
1.7       haad      761:                }
1.31      chs       762:                table_en = kmem_alloc(sizeof(dm_table_entry_t), KM_SLEEP);
1.2       haad      763:                prop_dictionary_get_uint64(target_dict, DM_TABLE_START,
                    764:                    &table_en->start);
                    765:                prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH,
                    766:                    &table_en->length);
                    767: 
                    768:                table_en->target = target;
                    769:                table_en->dm_dev = dmv;
                    770:                table_en->target_config = NULL;
1.20      haad      771: 
1.2       haad      772:                /*
                    773:                 * There is a parameter string after dm_target_spec
                    774:                 * structure which  points to /dev/wd0a 284 part of
                    775:                 * table. String str points to this text. This can be
                    776:                 * null and therefore it should be checked before we try to
                    777:                 * use it.
                    778:                 */
1.15      haad      779:                prop_dictionary_get_cstring(target_dict,
1.20      haad      780:                    DM_TABLE_PARAMS, (char **) &str);
                    781: 
1.30      christos  782:                if (SLIST_EMPTY(tbl) || last_table == NULL)
1.2       haad      783:                        /* insert this table to head */
                    784:                        SLIST_INSERT_HEAD(tbl, table_en, next);
                    785:                else
                    786:                        SLIST_INSERT_AFTER(last_table, table_en, next);
1.20      haad      787: 
1.2       haad      788:                /*
                    789:                 * Params string is different for every target,
                    790:                 * therfore I have to pass it to target init
                    791:                 * routine and parse parameters there.
                    792:                 */
1.20      haad      793: 
1.2       haad      794:                if ((ret = target->init(dmv, &table_en->target_config,
1.15      haad      795:                            str)) != 0) {
1.4       haad      796:                        dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
1.2       haad      797:                        dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
1.15      haad      798:                        free(str, M_TEMP);
                    799: 
1.4       haad      800:                        dm_dev_unbusy(dmv);
1.28      mlelstv   801:                        prop_object_iterator_release(iter);
1.2       haad      802:                        return ret;
                    803:                }
                    804:                last_table = table_en;
1.15      haad      805:                free(str, M_TEMP);
1.2       haad      806:        }
                    807:        prop_object_iterator_release(iter);
1.20      haad      808: 
1.2       haad      809:        DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
                    810:        atomic_or_32(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
1.20      haad      811: 
1.2       haad      812:        dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
                    813:        dm_dev_unbusy(dmv);
                    814:        return 0;
                    815: }
1.32      christos  816: 
1.2       haad      817: /*
                    818:  * Get description of all tables loaded to device from kernel
                    819:  * and send it to libdevmapper.
                    820:  *
                    821:  * Output dictionary for every table:
                    822:  *
                    823:  * <key>cmd_data</key>
                    824:  * <array>
                    825:  *   <dict>
                    826:  *    <key>type<key>
                    827:  *    <string>...</string>
                    828:  *
                    829:  *    <key>start</key>
                    830:  *    <integer>...</integer>
                    831:  *
                    832:  *    <key>length</key>
                    833:  *    <integer>...</integer>
                    834:  *
                    835:  *    <key>params</key>
                    836:  *    <string>...</string>
                    837:  *   </dict>
                    838:  * </array>
                    839:  *
                    840:  */
                    841: int
                    842: dm_table_status_ioctl(prop_dictionary_t dm_dict)
                    843: {
                    844:        dm_dev_t *dmv;
                    845:        dm_table_t *tbl;
                    846:        dm_table_entry_t *table_en;
                    847: 
                    848:        prop_array_t cmd_array;
                    849:        prop_dictionary_t target_dict;
1.20      haad      850: 
1.29      justin    851:        uint32_t minor, flags;
1.20      haad      852: 
1.2       haad      853:        const char *name, *uuid;
                    854:        char *params;
1.17      haad      855:        int table_type;
1.20      haad      856: 
1.2       haad      857:        dmv = NULL;
                    858:        uuid = NULL;
                    859:        name = NULL;
                    860:        params = NULL;
                    861:        flags = 0;
                    862: 
                    863:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
                    864:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
                    865:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
                    866:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
                    867: 
                    868:        cmd_array = prop_array_create();
1.20      haad      869: 
                    870:        if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
1.2       haad      871:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    872:                return ENOENT;
                    873:        }
1.20      haad      874:        /*
                    875:         * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
                    876:         * INACTIVE TABLE
                    877:         */
1.17      haad      878:        if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
                    879:                table_type = DM_TABLE_INACTIVE;
                    880:        else
                    881:                table_type = DM_TABLE_ACTIVE;
1.20      haad      882: 
1.37    ! tkusumi   883:        if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE)) {
1.2       haad      884:                DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
1.37    ! tkusumi   885:        } else {
1.2       haad      886:                DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
1.20      haad      887: 
1.2       haad      888:                if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
                    889:                        DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
1.37    ! tkusumi   890:                else
1.2       haad      891:                        DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
                    892:        }
1.20      haad      893: 
1.2       haad      894:        if (dmv->flags & DM_SUSPEND_FLAG)
                    895:                DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
1.20      haad      896: 
1.2       haad      897:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
1.20      haad      898: 
1.2       haad      899:        aprint_debug("Status of device tables: %s--%d\n",
                    900:            name, dmv->table_head.cur_active_table);
1.20      haad      901: 
1.17      haad      902:        tbl = dm_table_get_entry(&dmv->table_head, table_type);
1.20      haad      903: 
                    904:        SLIST_FOREACH(table_en, tbl, next) {
1.2       haad      905:                target_dict = prop_dictionary_create();
                    906:                aprint_debug("%016" PRIu64 ", length %016" PRIu64
                    907:                    ", target %s\n", table_en->start, table_en->length,
                    908:                    table_en->target->name);
                    909: 
                    910:                prop_dictionary_set_uint64(target_dict, DM_TABLE_START,
                    911:                    table_en->start);
                    912:                prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH,
                    913:                    table_en->length);
                    914: 
                    915:                prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE,
                    916:                    table_en->target->name);
                    917: 
                    918:                /* dm_table_get_cur_actv.table ?? */
                    919:                prop_dictionary_set_int32(target_dict, DM_TABLE_STAT,
                    920:                    dmv->table_head.cur_active_table);
                    921: 
1.34      tkusumi   922:                /*
                    923:                 * Explicitly clear DM_TABLE_PARAMS to prevent dmsetup(8) from
                    924:                 * printing junk when DM_TABLE_PARAMS was never initialized.
                    925:                 */
                    926:                prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS, "");
                    927: 
1.25      joerg     928:                if (flags & DM_STATUS_TABLE_FLAG) {
1.2       haad      929:                        params = table_en->target->status
                    930:                            (table_en->target_config);
                    931: 
1.20      haad      932:                        if (params != NULL) {
1.2       haad      933:                                prop_dictionary_set_cstring(target_dict,
                    934:                                    DM_TABLE_PARAMS, params);
1.20      haad      935: 
1.14      haad      936:                                kmem_free(params, DM_MAX_PARAMS_SIZE);
1.2       haad      937:                        }
                    938:                }
                    939:                prop_array_add(cmd_array, target_dict);
                    940:                prop_object_release(target_dict);
                    941:        }
                    942: 
1.17      haad      943:        dm_table_release(&dmv->table_head, table_type);
1.2       haad      944:        dm_dev_unbusy(dmv);
1.17      haad      945: 
                    946:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
1.2       haad      947:        prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
                    948:        prop_object_release(cmd_array);
1.20      haad      949: 
1.2       haad      950:        return 0;
                    951: }
                    952: 
                    953: /*
                    954:  * For every call I have to set kernel driver version.
                    955:  * Because I can have commands supported only in other
1.20      haad      956:  * newer/later version. This routine is called for every
1.2       haad      957:  * ioctl command.
                    958:  */
                    959: int
                    960: dm_check_version(prop_dictionary_t dm_dict)
                    961: {
                    962:        size_t i;
1.29      justin    963:        uint32_t dm_version[3];
1.2       haad      964:        prop_array_t ver;
1.20      haad      965: 
1.2       haad      966:        ver = prop_dictionary_get(dm_dict, DM_IOCTL_VERSION);
1.20      haad      967: 
                    968:        for (i = 0; i < 3; i++)
1.2       haad      969:                prop_array_get_uint32(ver, i, &dm_version[i]);
                    970: 
1.20      haad      971:        if (DM_VERSION_MAJOR != dm_version[0] || DM_VERSION_MINOR < dm_version[1]) {
1.2       haad      972:                aprint_debug("libdevmapper/kernel version mismatch "
                    973:                    "kernel: %d.%d.%d libdevmapper: %d.%d.%d\n",
                    974:                    DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL,
                    975:                    dm_version[0], dm_version[1], dm_version[2]);
1.20      haad      976: 
1.2       haad      977:                return EIO;
                    978:        }
                    979:        prop_array_set_uint32(ver, 0, DM_VERSION_MAJOR);
                    980:        prop_array_set_uint32(ver, 1, DM_VERSION_MINOR);
                    981:        prop_array_set_uint32(ver, 2, DM_VERSION_PATCHLEVEL);
                    982: 
1.17      haad      983:        prop_dictionary_set(dm_dict, DM_IOCTL_VERSION, ver);
1.20      haad      984: 
1.2       haad      985:        return 0;
                    986: }

CVSweb <webmaster@jp.NetBSD.org>