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

1.1.2.1   haad        1: /*
                      2:  * Copyright (c) 1996, 1997, 1998, 1999, 2002 The NetBSD Foundation, Inc.
                      3:  * All rights reserved.
                      4:  *
                      5:  * This code is derived from software contributed to The NetBSD Foundation
                      6:  * by Adam Hamsik.
                      7:  *
                      8:  * Redistribution and use in source and binary forms, with or without
                      9:  * modification, are permitted provided that the following conditions
                     10:  * are met:
                     11:  * 1. Redistributions of source code must retain the above copyright
                     12:  *    notice, this list of conditions and the following disclaimer.
                     13:  * 2. Redistributions in binary form must reproduce the above copyright
                     14:  *    notice, this list of conditions and the following disclaimer in the
                     15:  *    documentation and/or other materials provided with the distribution.
                     16:  *
                     17:  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
                     18:  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
                     19:  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                     20:  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
                     21:  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
                     22:  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
                     23:  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
                     24:  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
                     25:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
                     26:  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
                     27:  * POSSIBILITY OF SUCH DAMAGE.
                     28:  */
                     29: 
                     30: #include <sys/types.h>
                     31: #include <sys/param.h>
                     32: 
                     33: #include <sys/errno.h>
                     34: #include <sys/ioctl.h>
                     35: #include <sys/ioccom.h>
                     36: #include <sys/kmem.h>
                     37: #include <sys/lkm.h>
                     38: #include <sys/namei.h>
                     39: #include <sys/vnode.h>
                     40: 
                     41: #include <miscfs/specfs/specdev.h>
                     42: 
                     43: #include <machine/int_fmtio.h>
                     44: 
                     45: #include "netbsd-dm.h"
                     46: #include "dm.h"
                     47: 
                     48: extern struct dm_softc *dm_sc;
                     49: 
                     50: #define DM_REMOVE_FLAG(flag, name) do {                                           \
                     51:                prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag);  \
                     52:                flag &= ~name;                                             \
                     53:                prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag);   \
                     54: } while (/*CONSTCOND*/0)
                     55: 
                     56: #define DM_ADD_FLAG(flag, name) do {                                      \
                     57:                prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag);  \
                     58:                flag |= name;                                              \
                     59:                prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag);   \
                     60: } while (/*CONSTCOND*/0)
                     61: 
                     62: static int dm_dbg_print_flags(int);
                     63: 
                     64: /*
                     65:  * Print flags sent to the kernel from libevmapper.
                     66:  */
                     67: static int
                     68: dm_dbg_print_flags(int flags)
                     69: {
                     70:        aprint_verbose("dbg_print --- %d\n",flags);
                     71:        
                     72:        if (flags & DM_READONLY_FLAG)
                     73:                aprint_verbose("dbg_flags: DM_READONLY_FLAG set In/Out\n");
                     74: 
                     75:        if (flags & DM_SUSPEND_FLAG)
                     76:                aprint_verbose("dbg_flags: DM_SUSPEND_FLAG set In/Out \n");
                     77: 
                     78:        if (flags & DM_PERSISTENT_DEV_FLAG)
                     79:                aprint_verbose("dbg_flags: DM_PERSISTENT_DEV_FLAG set In\n");
                     80: 
                     81:        if (flags & DM_STATUS_TABLE_FLAG)
                     82:                aprint_verbose("dbg_flags: DM_STATUS_TABLE_FLAG set In\n");
                     83: 
                     84:        if (flags & DM_ACTIVE_PRESENT_FLAG)
                     85:                aprint_verbose("dbg_flags: DM_ACTIVE_PRESENT_FLAG set Out\n");
                     86: 
                     87:        if (flags & DM_INACTIVE_PRESENT_FLAG)
1.1.2.2 ! haad       88:                aprint_verbose("dbg_flags: DM_INACTIVE_PRESENT_FLAG set Out\n");
1.1.2.1   haad       89: 
                     90:        if (flags & DM_BUFFER_FULL_FLAG)
                     91:                aprint_verbose("dbg_flags: DM_BUFFER_FULL_FLAG set Out\n");
                     92: 
                     93:        if (flags & DM_SKIP_BDGET_FLAG)
                     94:                aprint_verbose("dbg_flags: DM_SKIP_BDGET_FLAG set In\n");
                     95: 
                     96:        if (flags & DM_SKIP_LOCKFS_FLAG)
                     97:                aprint_verbose("dbg_flags: DM_SKIP_LOCKFS_FLAG set In\n");
                     98: 
                     99:        if (flags & DM_NOFLUSH_FLAG)
                    100:                aprint_verbose("dbg_flags: DM_NOFLUSH_FLAG set In\n");
                    101:        
                    102:        return 0;
                    103: }
                    104: 
1.1.2.2 ! haad      105: /*
        !           106:  * Get version ioctl call I do it as default therefore this
        !           107:  * function is unused now.
        !           108:  */
1.1.2.1   haad      109: int
                    110: dm_get_version_ioctl(prop_dictionary_t dm_dict)
                    111: {
                    112:        int r;
                    113: 
                    114:        r = 0;
                    115: 
                    116:        aprint_verbose("dm_get_version_ioctl called\n");
                    117: 
                    118:        return 0;
                    119: }
                    120: 
                    121: /*
                    122:  * Get list of all available targets from global
                    123:  * target list and sent them back to libdevmapper.
                    124:  */
                    125: int
                    126: dm_list_versions_ioctl(prop_dictionary_t dm_dict)
                    127: {
                    128:        prop_array_t target_list;
                    129:        
                    130:        int r;
                    131:        uint32_t flags;
                    132:        
                    133:        r = 0;
                    134: 
                    135:        aprint_verbose("dm_list_versions_ioctl called\n");
                    136: 
1.1.2.2 ! haad      137:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.1.2.1   haad      138:        
                    139:        dm_dbg_print_flags(flags);
                    140: 
                    141:        target_list = dm_target_prop_list();
                    142: 
1.1.2.2 ! haad      143:        prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list);
1.1.2.1   haad      144:        
                    145:        return r;
                    146: }
                    147: 
                    148: /*
                    149:  * Create in-kernel entry for device. Device attributes such as name, uuid are
                    150:  * taken from proplib dictionary.
                    151:  */
                    152: int
                    153: dm_dev_create_ioctl(prop_dictionary_t dm_dict)
                    154: {
                    155:        struct dm_dev *dmv;
                    156:        const char *name, *uuid;
                    157:        int r,flags;
                    158:        
                    159:        r = 0;
                    160:        flags = 0;
                    161:        name = NULL;    
                    162:        uuid = NULL;
                    163: 
                    164:        /* Get needed values from dictionary. */
1.1.2.2 ! haad      165:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           166:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           167:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.1.2.1   haad      168:        
                    169:        dm_dbg_print_flags(flags);
                    170: 
                    171:        /* Lookup name and uuid if device already exist quit. */
                    172:        if ((dm_dev_lookup_name(name) != NULL) &&
                    173:            (dm_dev_lookup_uuid(uuid) != NULL)) {
                    174:                DM_ADD_FLAG(flags, DM_EXISTS_FLAG); /* Device already exists */
                    175:                return EEXIST;
                    176:        }
                    177: 
                    178: 
                    179:        if ((dmv = dm_dev_alloc()) == NULL)
                    180:                return ENOMEM;
                    181: /*     printf("%d---%d\n",sizeof(dmv->uuid),DM_UUID_LEN);
                    182:        printf("%s\n",uuid);
                    183:        if (uuid)
                    184:        memcpy(dmv->uuid,uuid,DM_UUID_LEN);*/
                    185:        printf("%s\n",name);
                    186:        if (name)
1.1.2.2 ! haad      187:                strlcpy(dmv->name, name, DM_NAME_LEN);
1.1.2.1   haad      188: 
                    189:        dmv->flags = flags;
                    190: 
                    191:        dmv->minor = ++(dm_sc->sc_minor_num);
                    192: 
                    193:        dmv->ref_cnt = 0;
                    194:        dmv->event_nr = 0;
                    195:        dmv->cur_active_table = 0;
                    196: 
                    197:        /* Initialize tables. */
                    198:        SLIST_INIT(&dmv->tables[0]);
                    199:        SLIST_INIT(&dmv->tables[1]);
                    200: 
                    201:        /* init device list of physical devices. */
                    202:        SLIST_INIT(&dmv->pdevs);
                    203:        /*
                    204:         * Locking strategy here is this: this is per device mutex lock
                    205:         * and it should be taken when we work with device. Almost all
                    206:         * ioctl callbacks for tables and devices must acquire this lock.
                    207:         */
                    208: 
1.1.2.2 ! haad      209:        prop_dictionary_set_uint64(dm_dict, DM_IOCTL_DEV, dmv->minor);
1.1.2.1   haad      210:        
1.1.2.2 ! haad      211:        mutex_init(&dmv->dev_mtx, MUTEX_DEFAULT, IPL_NONE);
1.1.2.1   haad      212:    
                    213:        /* Test readonly flag change anything only if it is not set*/
                    214:        if (flags & DM_READONLY_FLAG)
                    215:                dm_dev_free(dmv);
                    216:        else
                    217:                r = dm_dev_insert(dmv);
                    218:        
                    219:        return r;
                    220: }
                    221: 
                    222: /*
                    223:  * Get list of created device-mapper devices fromglobal list and
                    224:  * send it to kernel.
                    225:  *
                    226:  * Output dictionary:
                    227:  *
                    228:  * <key>cmd_data</key>
                    229:  *  <array>
                    230:  *   <dict>
                    231:  *    <key>name<key>
                    232:  *    <string>...</string>
                    233:  *
                    234:  *    <key>dev</key>
                    235:  *    <integer>...</integer>
                    236:  *   </dict>
                    237:  *  </array>
                    238:  * 
                    239:  */
                    240: int
                    241: dm_dev_list_ioctl(prop_dictionary_t dm_dict)
                    242: {
                    243:        prop_array_t dev_list;
                    244:        
                    245:        int r;
                    246:        uint32_t flags;
                    247:        
                    248:        r = 0;
                    249: 
                    250:        aprint_verbose("dm_dev_list called\n");
                    251: 
1.1.2.2 ! haad      252:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.1.2.1   haad      253:        
                    254:        dm_dbg_print_flags(flags);
                    255:        
                    256:        dev_list = dm_dev_prop_list();
                    257: 
1.1.2.2 ! haad      258:        prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, dev_list);
1.1.2.1   haad      259:        
                    260:        return 0;
                    261: }
                    262: 
                    263: /*
                    264:  * Rename selected devices old name is in struct dm_ioctl.
                    265:  * newname is taken from dictionary
                    266:  *
                    267:  * <key>cmd_data</key>
                    268:  *  <array>
                    269:  *   <string>...</string>
                    270:  *  </array>
                    271:  */
                    272: int
                    273: dm_dev_rename_ioctl(prop_dictionary_t dm_dict)
                    274: {
                    275:        prop_array_t cmd_array;
                    276:        struct dm_dev *dmv;
                    277:        
                    278:        const char *name,*uuid,*n_name;
                    279:        uint32_t flags;
                    280: 
                    281:        name = NULL;
                    282:        uuid = NULL;
                    283:        
                    284:        /* Get needed values from dictionary. */
1.1.2.2 ! haad      285:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           286:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           287:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
        !           288:        cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
1.1.2.1   haad      289: 
1.1.2.2 ! haad      290:        prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
1.1.2.1   haad      291:        
                    292:        if (strlen(n_name) + 1 > DM_NAME_LEN)
                    293:                return EINVAL;
                    294:        
                    295:        if (((dmv = dm_dev_lookup_uuid(uuid)) == NULL) ||
                    296:            (dmv = dm_dev_lookup_name(name)) == NULL) {
                    297:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    298:                return ENOENT;
                    299:        }
                    300:        
                    301:        /* Test readonly flag change anything only if it is not set*/
                    302:        if (!(flags & DM_READONLY_FLAG))
1.1.2.2 ! haad      303:                strlcpy(dmv->name, n_name, DM_NAME_LEN);
1.1.2.1   haad      304:        
                    305:        return 0;
                    306: }
                    307: 
                    308: /*
                    309:  * Remove device from global list I have to remove active
                    310:  * and inactive tables first and decrement reference_counters
                    311:  * for used pdevs.
                    312:  */
                    313: int
                    314: dm_dev_remove_ioctl(prop_dictionary_t dm_dict)
                    315: {
                    316:        struct dm_dev *dmv;
                    317: 
                    318:        const char *name, *uuid;
                    319:        uint32_t flags;
                    320: 
                    321:        name = NULL;
                    322:        uuid = NULL;
                    323:        
                    324:        /* Get needed values from dictionary. */
1.1.2.2 ! haad      325:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           326:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           327:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.1.2.1   haad      328:        
                    329:        dm_dbg_print_flags(flags);
                    330:        
                    331:        if (((dmv = dm_dev_lookup_uuid(uuid)) == NULL) &&
                    332:            (dmv = dm_dev_lookup_name(name)) == NULL) {
                    333:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    334:                return ENOENT;
                    335:        }
                    336:        
                    337:        if (!(flags & DM_READONLY_FLAG)) {
                    338:                if (dmv->ref_cnt == 0){
                    339:                        /* Destroy active table first.  */
                    340:                        dm_table_destroy(&dmv->tables[dmv->cur_active_table]);
                    341: 
                    342:                        /* Destroy unactive table if exits, too. */
                    343:                        if (!SLIST_EMPTY(&dmv->tables[1 - dmv->cur_active_table]))
                    344:                                dm_table_destroy(&dmv->tables[1 - dmv->cur_active_table]);
                    345:                        
                    346:                        /* Decrement reference counters for all pdevs from this
                    347:                           device if they are unused close vnode and remove them
                    348:                           from global pdev list, too. */
                    349:                        dm_pdev_decr(&dmv->pdevs);
                    350:        
                    351:                        /* Test readonly flag change anything only if it is not set*/
                    352:        
                    353:                        dm_dev_rem(name); /* XXX. try to use uuid, too */
                    354:                }
                    355:                
                    356:        }
                    357:        return 0;
                    358: }
                    359: 
                    360: /*
                    361:  * Return actual state of device to libdevmapper.
                    362:  */
                    363: int
                    364: dm_dev_status_ioctl(prop_dictionary_t dm_dict)
                    365: {
                    366:        struct dm_dev *dmv;
                    367:        const char *name, *uuid;
                    368:        uint32_t flags;
                    369:                
                    370:        name = NULL;
                    371:        uuid = NULL;
                    372:        
1.1.2.2 ! haad      373:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           374:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           375:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.1.2.1   haad      376:        
                    377:        if (((dmv = dm_dev_lookup_name(name)) == NULL) &&
                    378:            ((dmv = dm_dev_lookup_uuid(uuid)) == NULL)) {
                    379:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    380:                return 0;
                    381:        }
                    382:        
1.1.2.2 ! haad      383:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->ref_cnt);
        !           384:        prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags);
1.1.2.1   haad      385:        
1.1.2.2 ! haad      386:        prop_dictionary_set_uint64(dm_dict, DM_IOCTL_DEV, dmv->minor);
1.1.2.1   haad      387:        
                    388:        return 0;
                    389: }
                    390: 
                    391: /*
                    392:  * Unsupported on NetBSD.
                    393:  */
                    394: int
                    395: dm_dev_suspend_ioctl(prop_dictionary_t dm_dict)
                    396: {
                    397:        return 0;
                    398: }
                    399: 
                    400: /*
                    401:  * Unsupported on NetBSD.
                    402:  */
                    403: int
                    404: dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
                    405: {
                    406: //     DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
                    407: 
                    408:        return 0;
                    409: }
                    410: 
                    411: /*
                    412:  * Table management routines
                    413:  * lvm2tools doens't send name/uuid to kernel with table for lookup I have to use minor number.
                    414:  */
                    415: 
                    416: 
                    417: /*
                    418:  * Remove active table from device.
                    419:  */
                    420: int
                    421: dm_table_clear_ioctl(prop_dictionary_t dm_dict)
                    422: {
                    423:        struct dm_dev *dmv;
                    424:        struct dm_table  *tbl;
                    425: 
                    426:        const char *name, *uuid;
                    427:        int flags;
                    428: 
                    429:        dmv  = NULL;
                    430:        name = NULL;
                    431:        uuid = NULL;
                    432:        
1.1.2.2 ! haad      433:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           434:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           435:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
1.1.2.1   haad      436:        
1.1.2.2 ! haad      437:        aprint_verbose("Clearing inactive table from device: %s--%s\n",
        !           438:            name, uuid);
1.1.2.1   haad      439:        
                    440:        if (((dmv = dm_dev_lookup_name(name)) == NULL) &&
                    441:            ((dmv = dm_dev_lookup_uuid(uuid)) == NULL)) {
                    442:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    443:                return ENOENT;
                    444:        }
                    445:        
                    446:        /* Select unused table */
                    447:        tbl = &dmv->tables[1-dmv->cur_active_table]; 
                    448: 
                    449:        /* Test readonly flag change anything only if it is not set*/
                    450:        if (!(flags & DM_READONLY_FLAG))
                    451:                        dm_table_destroy(tbl);
                    452: 
                    453:        return 0;
                    454: }
                    455: 
                    456: /*
                    457:  * Get list of physical devices for active table.
                    458:  * Get dev_t from pdev vnode and insert it into cmd_array.
                    459:  *
                    460:  * XXX. This function is called from lvm2tools to get information
                    461:  *      about physical devices, too e.g. during vgcreate. 
                    462:  */
                    463: int
                    464: dm_table_deps_ioctl(prop_dictionary_t dm_dict)
                    465: {
                    466:        int error;
                    467:        struct dm_dev *dmv;
                    468:        struct dm_pdev *dmp;
                    469:        struct vattr va;
                    470:        
                    471:        prop_array_t cmd_array;
                    472:        
                    473:        const char *name, *uuid;
                    474:        int flags;
                    475:        uint64_t dev;
                    476:        
                    477:        size_t i;
                    478: 
                    479:        name = NULL;
                    480:        uuid = NULL;
                    481:        dmv  = NULL;
                    482:        
                    483:        i=0;
                    484: 
1.1.2.2 ! haad      485:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           486:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           487:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
        !           488:        prop_dictionary_get_uint64(dm_dict, DM_IOCTL_DEV, &dev);
1.1.2.1   haad      489:        
                    490:        cmd_array = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA);
                    491: 
                    492:        if (((dmv = dm_dev_lookup_name(name)) == NULL) &&
                    493:            ((dmv = dm_dev_lookup_uuid(uuid)) == NULL) &&
                    494:            ((dmv = dm_dev_lookup_minor(minor(dev))) == NULL)) {
                    495:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    496:                return ENOENT;
                    497:        }
                    498:        
                    499:        aprint_verbose("Getting table deps for device: %s\n",name);
                    500:                
                    501:        SLIST_FOREACH(dmp, &dmv->pdevs, next_pdev){
                    502: 
1.1.2.2 ! haad      503:                if ((error = VOP_GETATTR(dmp->pdev_vnode, &va, curlwp->l_cred))
        !           504:                    != 0)
1.1.2.1   haad      505:                        return (error);
                    506:                
1.1.2.2 ! haad      507:                prop_array_set_uint64(cmd_array, i, (uint64_t)va.va_rdev);
1.1.2.1   haad      508: 
                    509:                i++;
                    510:        }
                    511:        
                    512:        return 0;
                    513: }
                    514: 
                    515: /*
                    516:  * Load new table/tables to device.
                    517:  * Call apropriate target init routine open all physical pdev's and
                    518:  * link them to device. For other targets mirror, strip, snapshot
                    519:  * etc. also add dependency devices to upcalls list.
                    520:  *
                    521:  * XXX. It would be usefull to refactorize this routine to be shorter ?
                    522:  */
                    523: int
                    524: dm_table_load_ioctl(prop_dictionary_t dm_dict)
                    525: {
                    526:        struct dm_dev *dmv;
                    527:        struct dm_pdev *dmp;
                    528:        struct dm_table_entry *table_en, *last_table;
                    529:        struct dm_table  *tbl;
                    530:        struct dm_target *target;
                    531: 
                    532:        prop_object_iterator_t iter;
                    533:        prop_array_t cmd_array;
                    534:        prop_dictionary_t target_dict;
                    535:        
                    536:        const char *name, *uuid, *type, *str_ptr;
                    537: 
                    538:        uint32_t flags;
                    539: 
                    540:        uint64_t dev;
                    541:        
                    542:        char *dev_name,*str;
                    543: 
                    544:        flags = 0;
                    545:        name = NULL;
                    546:        uuid = NULL;
                    547:        dmv = NULL;
                    548:        dmp = NULL;
                    549:        last_table = NULL;
                    550:        str_ptr = NULL;
                    551: 
                    552:        char *xml;
                    553:        xml = prop_dictionary_externalize(dm_dict);
                    554:        printf("%s\n",xml);
                    555:                
1.1.2.2 ! haad      556:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           557:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           558:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
        !           559:        prop_dictionary_get_uint64(dm_dict, DM_IOCTL_DEV, &dev);
1.1.2.1   haad      560:        
1.1.2.2 ! haad      561:        cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
1.1.2.1   haad      562:        iter = prop_array_iterator(cmd_array);
                    563:        
                    564:        dm_dbg_print_flags(flags);      
                    565: 
                    566:        aprint_verbose("Loading table to device: %s--%s\n",name,uuid);
                    567:        
                    568:        if (((dmv = dm_dev_lookup_name(name)) == NULL) &&
                    569:            ((dmv = dm_dev_lookup_uuid(uuid)) == NULL) &&
                    570:            ((dmv = dm_dev_lookup_minor(minor(dev))) == NULL)) {
                    571:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    572:                return ENOENT;
                    573:        }
                    574:        
                    575:        /* Select unused table */
                    576:        tbl = &dmv->tables[1-dmv->cur_active_table]; 
                    577: 
                    578:        /*
                    579:         * I have to check if this table slot is not used by another table list.
                    580:         * if it is used I should free them.
                    581:         */
                    582: 
                    583:        dm_table_destroy(tbl);
                    584:        
                    585:        while((target_dict = prop_object_iterator_next(iter)) != NULL){
                    586: 
1.1.2.2 ! haad      587:                prop_dictionary_get_cstring_nocopy(target_dict,
        !           588:                    DM_TABLE_TYPE, &type);
1.1.2.1   haad      589:                
1.1.2.2 ! haad      590:                /*
        !           591:                 * If we want to deny table with 2 or more different
        !           592:                 * target we should do it here
        !           593:                 */
1.1.2.1   haad      594:                if ((target = dm_target_lookup_name(type)) == NULL)
                    595:                        return ENOENT;
                    596:                
1.1.2.2 ! haad      597:                if ((table_en=kmem_alloc(sizeof(struct dm_table_entry),
        !           598:                            KM_NOSLEEP)) == NULL)
1.1.2.1   haad      599:                        return ENOMEM;
                    600:                
1.1.2.2 ! haad      601:                prop_dictionary_get_uint64(target_dict, DM_TABLE_START,
        !           602:                    &table_en->start);
        !           603:                prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH,
        !           604:                    &table_en->length);
1.1.2.1   haad      605: 
                    606:                table_en->target=target;
                    607:                table_en->dm_dev=dmv;
                    608:                
                    609:                /*
                    610:                 * There is a parameter string after dm_target_spec
                    611:                 * structure which  points to /dev/wd0a 284 part of
                    612:                 * table. String str points to this text.
                    613:                 */
                    614: 
                    615:                prop_dictionary_get_cstring_nocopy(target_dict,
                    616:                    DM_TABLE_PARAMS, (const char**)&str);
                    617: 
                    618:                if (strlen(str) != 0) {
                    619: 
                    620:                        str_ptr = str; /* save pointer to start of string */
                    621:                        
1.1.2.2 ! haad      622:                        aprint_verbose("trg_str: %s\n", str);
1.1.2.1   haad      623:                        
                    624:                        dev_name = strsep(&str," ");
                    625: 
1.1.2.2 ! haad      626:                        aprint_verbose("namei: %s, str: %s\n", dev_name, str);
1.1.2.1   haad      627:                                                
                    628:                        if (!(flags & DM_READONLY_FLAG)){
                    629: 
                    630:                                if ((dmp = dm_pdev_insert(dev_name)) == NULL){
1.1.2.2 ! haad      631:                                        kmem_free(table_en,
        !           632:                                            sizeof(struct dm_table_entry));
1.1.2.1   haad      633:                                        return ENOENT;
                    634:                                }
                    635: 
                    636:                                /* insert pdev to device list  */
1.1.2.2 ! haad      637:                                SLIST_INSERT_HEAD(&dmv->pdevs, dmp, next_pdev);
1.1.2.1   haad      638:                        }
                    639:                }
                    640:                
                    641:                /* Test readonly flag change anything only if it is not set*/
                    642:                if (!(flags & DM_READONLY_FLAG)){
                    643: 
                    644:                        if (SLIST_EMPTY(tbl))
                    645:                                /* insert this table to head */
1.1.2.2 ! haad      646:                                SLIST_INSERT_HEAD(tbl, table_en, next);
1.1.2.1   haad      647:                        else
1.1.2.2 ! haad      648:                                SLIST_INSERT_AFTER(last_table, table_en, next);
        !           649: 
1.1.2.1   haad      650:                        prop_dictionary_get_cstring(target_dict,
1.1.2.2 ! haad      651:                            DM_TABLE_PARAMS, (char **)&table_en->params);
1.1.2.1   haad      652: 
                    653:                        /*
                    654:                         * XXX I have to calculate argc
                    655:                         */
                    656:                        if (target->init != NULL)
1.1.2.2 ! haad      657:                                target->init(dmv, &table_en->target_config,
        !           658:                                    2, &str_ptr);
1.1.2.1   haad      659: 
                    660:                        last_table = table_en;
                    661:                        
                    662:                } else {
1.1.2.2 ! haad      663:                        kmem_free(table_en, sizeof(struct dm_table_entry));
1.1.2.1   haad      664:                        dm_pdev_destroy(dmp);
                    665:                }
                    666:                        
                    667:        }
                    668:        
                    669:        dmv->cur_active_table = 1 - dmv->cur_active_table;
                    670: 
                    671:        prop_object_release(cmd_array);
                    672: 
                    673:        DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
                    674:        
                    675:        return 0;
                    676: }
                    677: 
                    678: /*
                    679:  * Get description of all tables loaded to device from kernel
                    680:  * and send it to libdevmapper.
                    681:  *
                    682:  * Output dictionary for every table:
                    683:  *
                    684:  * <key>cmd_data</key>
                    685:  * <array>
                    686:  *   <dict>
                    687:  *    <key>type<key>
                    688:  *    <string>...</string>
                    689:  *
                    690:  *    <key>start</key>
                    691:  *    <integer>...</integer>
                    692:  *
                    693:  *    <key>length</key>
                    694:  *    <integer>...</integer>
                    695:  *
                    696:  *    <key>params</key>
                    697:  *    <string>...</string>
                    698:  *   </dict>
                    699:  * </array>
                    700:  *
                    701:  */
                    702: int
                    703: dm_table_status_ioctl(prop_dictionary_t dm_dict)
                    704: {
                    705:        struct dm_dev *dmv;
                    706:        struct dm_table  *tbl;
                    707:        struct dm_table_entry *table_en;
                    708: 
                    709:        prop_array_t cmd_array;
                    710:        prop_dictionary_t target_dict;
                    711:        
                    712:        uint32_t rec_size;
                    713:        uint64_t dev;
                    714:        
                    715:        const char *name, *uuid;
                    716:        int flags,i;
                    717:        
                    718:        dmv = NULL;
                    719:        uuid = NULL;
                    720:        name = NULL;
                    721: 
                    722:        flags = 0;
                    723:        rec_size = 0;
                    724:        i=0;
                    725: 
1.1.2.2 ! haad      726:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
        !           727:        prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
        !           728:        prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
        !           729:        prop_dictionary_get_uint64(dm_dict, DM_IOCTL_DEV, &dev);
1.1.2.1   haad      730: 
1.1.2.2 ! haad      731:        cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
1.1.2.1   haad      732:        
                    733:        if (((dmv = dm_dev_lookup_name(name)) == NULL) &&
                    734:            ((dmv = dm_dev_lookup_uuid(uuid)) == NULL) &&
                    735:            ((dmv = dm_dev_lookup_minor(minor(dev)))) == NULL) {
                    736:                DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
                    737:                return ENOENT;
                    738:        }
                    739:        
1.1.2.2 ! haad      740:        aprint_verbose("Status of device tables: %s--%d\n",
        !           741:            name, dmv->cur_active_table);
1.1.2.1   haad      742:        
                    743:        tbl = &dmv->tables[dmv->cur_active_table];
                    744: 
                    745:        SLIST_FOREACH(table_en,tbl,next)
                    746:        {
                    747:                target_dict = prop_dictionary_create();
1.1.2.2 ! haad      748:                aprint_verbose("%016" PRIu64 ", length %016" PRIu64
        !           749:                    ", target %s\n", table_en->start, table_en->length,
        !           750:                    table_en->target->name);
        !           751: 
        !           752:                prop_dictionary_set_uint64(target_dict, DM_TABLE_START,
        !           753:                    table_en->start);
        !           754:                prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH,
        !           755:                    table_en->length);
        !           756: 
        !           757:                prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE,
        !           758:                    table_en->target->name);
        !           759:                prop_dictionary_set_cstring(target_dict, DM_TABLE_PARAMS,
        !           760:                    table_en->params);
1.1.2.1   haad      761:                
1.1.2.2 ! haad      762:                prop_dictionary_set_int32(target_dict, DM_TABLE_STAT,
        !           763:                    dmv->cur_active_table);
1.1.2.1   haad      764: 
1.1.2.2 ! haad      765:                prop_array_set(cmd_array, i, target_dict);
1.1.2.1   haad      766: 
                    767:                prop_object_release(target_dict);
                    768: 
                    769:                DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
                    770:                                
                    771:                i++;
                    772:        }
                    773: 
                    774:        return 0;
                    775: }
                    776: 
                    777: 
                    778: /*
                    779:  * For every call I have to set kernel driver version.
                    780:  * Because I can have commands supported only in other
                    781:  * newer/later version. This routine is called for every 
                    782:  * ioctl command.
                    783:  */
                    784: int
                    785: dm_check_version(prop_dictionary_t dm_dict)
                    786: {
                    787:        size_t i;
                    788:        int dm_version[3];
                    789:        prop_array_t ver;
                    790:        int r;
                    791: 
                    792:        r = 0;
                    793:        
1.1.2.2 ! haad      794:        ver = prop_dictionary_get(dm_dict, DM_IOCTL_VERSION);
1.1.2.1   haad      795:        
                    796:        for(i=0; i < 3; i++) 
1.1.2.2 ! haad      797:                prop_array_get_uint32(ver, i, &dm_version[i]);
1.1.2.1   haad      798:        
                    799: 
1.1.2.2 ! haad      800:        if (DM_VERSION_MAJOR != dm_version[0] ||
        !           801:            DM_VERSION_MINOR < dm_version[1])
1.1.2.1   haad      802:        {
                    803:                aprint_verbose("libdevmapper/kernel version mismatch "
                    804:                    "kernel: %d.%d.%d libdevmapper: %d.%d.%d\n",
1.1.2.2 ! haad      805:                    DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL,
        !           806:                    dm_version[0], dm_version[1], dm_version[2]);
        !           807:                
1.1.2.1   haad      808:                r = EIO;
                    809:                goto out;
                    810:        }
                    811: 
1.1.2.2 ! haad      812:        prop_array_set_uint32(ver, 0, DM_VERSION_MAJOR);
        !           813:        prop_array_set_uint32(ver, 1, DM_VERSION_MINOR);
        !           814:        prop_array_set_uint32(ver, 2, DM_VERSION_PATCHLEVEL);
1.1.2.1   haad      815: 
                    816: out:   
                    817:        return r;
                    818: }

CVSweb <webmaster@jp.NetBSD.org>