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>