sys/libprop/prop_object_impl.h

   1 /*      $NetBSD: prop_object_impl.h,v 1.30 2009/09/13 18:45:10 pooka Exp $      */
   2
   3 /*-
   4  * Copyright (c) 2006 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   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  */
  31
  32 #ifndef _PROPLIB_PROP_OBJECT_IMPL_H_
  33 #define _PROPLIB_PROP_OBJECT_IMPL_H_
  34
  35 #if defined(_KERNEL) || defined(_STANDALONE)
  36 #include <sys/libkern.h>
  37 #else
  38 #include <inttypes.h>
  39 #endif
  40
  41 #include "prop_stack.h"
  42
  43 struct _prop_object_externalize_context {
  44         char *          poec_buf;               /* string buffer */
  45         size_t          poec_capacity;          /* capacity of buffer */
  46         size_t          poec_len;               /* current length of string */
  47         unsigned int    poec_depth;             /* nesting depth */
  48 };
  49
  50 bool            _prop_object_externalize_start_tag(
  51                                 struct _prop_object_externalize_context *,
  52                                 const char *);
  53 bool            _prop_object_externalize_end_tag(
  54                                 struct _prop_object_externalize_context *,
  55                                 const char *);
  56 bool            _prop_object_externalize_empty_tag(
  57                                 struct _prop_object_externalize_context *,
  58                                 const char *);
  59 bool            _prop_object_externalize_append_cstring(
  60                                 struct _prop_object_externalize_context *,
  61                                 const char *);
  62 bool            _prop_object_externalize_append_encoded_cstring(
  63                                 struct _prop_object_externalize_context *,
  64                                 const char *);
  65 bool            _prop_object_externalize_append_char(
  66                                 struct _prop_object_externalize_context *,
  67                                 unsigned char);
  68 bool            _prop_object_externalize_header(
  69                                 struct _prop_object_externalize_context *);
  70 bool            _prop_object_externalize_footer(
  71                                 struct _prop_object_externalize_context *);
  72
  73 struct _prop_object_externalize_context *
  74         _prop_object_externalize_context_alloc(void);
  75 void    _prop_object_externalize_context_free(
  76                                 struct _prop_object_externalize_context *);
  77
  78 typedef enum {
  79         _PROP_TAG_TYPE_START,                   /* e.g. <dict> */
  80         _PROP_TAG_TYPE_END,                     /* e.g. </dict> */
  81         _PROP_TAG_TYPE_EITHER
  82 } _prop_tag_type_t;
  83
  84 struct _prop_object_internalize_context {
  85         const char *poic_xml;
  86         const char *poic_cp;
  87
  88         const char *poic_tag_start;
  89
  90         const char *poic_tagname;
  91         size_t      poic_tagname_len;
  92         const char *poic_tagattr;
  93         size_t      poic_tagattr_len;
  94         const char *poic_tagattrval;
  95         size_t      poic_tagattrval_len;
  96
  97         bool   poic_is_empty_element;
  98         _prop_tag_type_t poic_tag_type;
  99 };
 100
 101 typedef enum {
 102         _PROP_OBJECT_FREE_DONE,
 103         _PROP_OBJECT_FREE_RECURSE,
 104         _PROP_OBJECT_FREE_FAILED
 105 } _prop_object_free_rv_t;
 106
 107 typedef enum {
 108         _PROP_OBJECT_EQUALS_FALSE,
 109         _PROP_OBJECT_EQUALS_TRUE,
 110         _PROP_OBJECT_EQUALS_RECURSE
 111 } _prop_object_equals_rv_t;
 112
 113 #define _PROP_EOF(c)            ((c) == '\0')
 114 #define _PROP_ISSPACE(c)        \
 115         ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r' || \
 116          _PROP_EOF(c))
 117
 118 #define _PROP_TAG_MATCH(ctx, t)                                 \
 119         _prop_object_internalize_match((ctx)->poic_tagname,     \
 120                                        (ctx)->poic_tagname_len, \
 121                                        (t), strlen(t))
 122
 123 #define _PROP_TAGATTR_MATCH(ctx, a)                             \
 124         _prop_object_internalize_match((ctx)->poic_tagattr,     \
 125                                        (ctx)->poic_tagattr_len, \
 126                                        (a), strlen(a))
 127
 128 #define _PROP_TAGATTRVAL_MATCH(ctx, a)                            \
 129         _prop_object_internalize_match((ctx)->poic_tagattrval,    \
 130                                        (ctx)->poic_tagattrval_len,\
 131                                        (a), strlen(a))
 132
 133 bool            _prop_object_internalize_find_tag(
 134                                 struct _prop_object_internalize_context *,
 135                                 const char *, _prop_tag_type_t);
 136 bool            _prop_object_internalize_match(const char *, size_t,
 137                                                const char *, size_t);
 138 prop_object_t   _prop_object_internalize_by_tag(
 139                                 struct _prop_object_internalize_context *);
 140 bool            _prop_object_internalize_decode_string(
 141                                 struct _prop_object_internalize_context *,
 142                                 char *, size_t, size_t *, const char **);
 143 prop_object_t   _prop_generic_internalize(const char *, const char *);
 144
 145 struct _prop_object_internalize_context *
 146                 _prop_object_internalize_context_alloc(const char *);
 147 void            _prop_object_internalize_context_free(
 148                                 struct _prop_object_internalize_context *);
 149
 150 #if !defined(_KERNEL) && !defined(_STANDALONE)
 151 bool            _prop_object_externalize_write_file(const char *,
 152                                                     const char *, size_t);
 153
 154 struct _prop_object_internalize_mapped_file {
 155         char *  poimf_xml;
 156         size_t  poimf_mapsize;
 157 };
 158
 159 struct _prop_object_internalize_mapped_file *
 160                 _prop_object_internalize_map_file(const char *);
 161 void            _prop_object_internalize_unmap_file(
 162                                 struct _prop_object_internalize_mapped_file *);
 163 #endif /* !_KERNEL && !_STANDALONE */
 164
 165 typedef bool (*prop_object_internalizer_t)(prop_stack_t, prop_object_t *,
 166                                 struct _prop_object_internalize_context *);
 167 typedef bool (*prop_object_internalizer_continue_t)(prop_stack_t,
 168                                 prop_object_t *,
 169                                 struct _prop_object_internalize_context *,
 170                                 void *, prop_object_t);
 171
 172         /* These are here because they're required by shared code. */
 173 bool            _prop_array_internalize(prop_stack_t, prop_object_t *,
 174                                 struct _prop_object_internalize_context *);
 175 bool            _prop_bool_internalize(prop_stack_t, prop_object_t *,
 176                                 struct _prop_object_internalize_context *);
 177 bool            _prop_data_internalize(prop_stack_t, prop_object_t *,
 178                                 struct _prop_object_internalize_context *);
 179 bool            _prop_dictionary_internalize(prop_stack_t, prop_object_t *,
 180                                 struct _prop_object_internalize_context *);
 181 bool            _prop_number_internalize(prop_stack_t, prop_object_t *,
 182                                 struct _prop_object_internalize_context *);
 183 bool            _prop_string_internalize(prop_stack_t, prop_object_t *,
 184                                 struct _prop_object_internalize_context *);
 185
 186 struct _prop_object_type {
 187         /* type indicator */
 188         uint32_t        pot_type;
 189         /* func to free object */
 190         _prop_object_free_rv_t
 191                         (*pot_free)(prop_stack_t, prop_object_t *);
 192         /*
 193          * func to free the child returned by pot_free with stack == NULL.
 194          *
 195          * Must be implemented if pot_free can return anything other than
 196          * _PROP_OBJECT_FREE_DONE.
 197          */
 198         void    (*pot_emergency_free)(prop_object_t);
 199         /* func to externalize object */
 200         bool    (*pot_extern)(struct _prop_object_externalize_context *,
 201                               void *);
 202         /* func to test quality */
 203         _prop_object_equals_rv_t
 204                 (*pot_equals)(prop_object_t, prop_object_t,
 205                               void **, void **,
 206                               prop_object_t *, prop_object_t *);
 207         /*
 208          * func to finish equality iteration.
 209          *
 210          * Must be implemented if pot_equals can return
 211          * _PROP_OBJECT_EQUALS_RECURSE
 212          */
 213         void    (*pot_equals_finish)(prop_object_t, prop_object_t);
 214         void    (*pot_lock)(void);
 215         void    (*pot_unlock)(void);
 216 };
 217
 218 struct _prop_object {
 219         const struct _prop_object_type *po_type;/* type descriptor */
 220         uint32_t        po_refcnt;              /* reference count */
 221 };
 222
 223 void            _prop_object_init(struct _prop_object *,
 224                                   const struct _prop_object_type *);
 225 void            _prop_object_fini(struct _prop_object *);
 226
 227 struct _prop_object_iterator {
 228         prop_object_t   (*pi_next_object)(void *);
 229         void            (*pi_reset)(void *);
 230         prop_object_t   pi_obj;
 231         uint32_t        pi_version;
 232 };
 233
 234 #define _PROP_NOTHREAD_ONCE_DECL(x)     static bool x = false;
 235 #define _PROP_NOTHREAD_ONCE_RUN(x,f)                                    \
 236         do {                                                            \
 237                 if ((x) == false) {                                     \
 238                         f();                                            \
 239                         x = true;                                       \
 240                 }                                                       \
 241         } while (/*CONSTCOND*/0)
 242
 243 #if defined(_KERNEL)
 244
 245 /*
 246  * proplib in the kernel...
 247  */
 248
 249 #include <sys/kernel.h>
 250 #include <sys/types.h>
 251 #include <sys/param.h>
 252 #include <machine/inttypes.h>
 253 #include <sys/malloc.h>
 254 #include <sys/objcache.h>
 255 #include <sys/systm.h>
 256 #include <sys/globaldata.h>
 257 #include <sys/mutex2.h>
 258 #include <sys/lock.h>
 259
 260 #define _PROP_ASSERT(x)                 KKASSERT(x)
 261
 262 #define _PROP_MALLOC(s, t)              kmalloc((s), (t), M_WAITOK)
 263 #define _PROP_CALLOC(s, t)              kmalloc((s), (t), M_WAITOK | M_ZERO)
 264 #define _PROP_REALLOC(v, s, t)          krealloc((v), (s), (t), M_WAITOK)
 265 #define _PROP_FREE(v, t)                kfree((v), (t))
 266
 267 #define _PROP_POOL_GET(p)               objcache_get((p), M_WAITOK)
 268 #define _PROP_POOL_PUT(p, v)            objcache_put((p), (v))
 269
 270 struct prop_pool_init {
 271         struct pool *pp;
 272         size_t size;
 273         const char *wchan;
 274 };
 275 #define _PROP_POOL_INIT(pp, size, wchan)                                \
 276 MALLOC_DEFINE(M_##pp, wchan, wchan);                                    \
 277 struct objcache *pp;                                                    \
 278 static void                                                                     \
 279 pp##_init(void)                                                         \
 280 {                                                                       \
 281         pp = objcache_create_simple(M_##pp, size);                      \
 282 }                                                                       \
 283 SYSINIT(pp##_init, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY, pp##_init, NULL)
 284
 285 #define _PROP_MALLOC_DEFINE(t, s, l)                                    \
 286                 MALLOC_DEFINE(t, s, l);
 287
 288 /*
 289  * NOTE: These locks might be held through a sleep so no spinlocks
 290  *       can be used.
 291  */
 292 #define _PROP_MUTEX_DECL_STATIC(x)      static struct lock x;
 293 #define _PROP_MUTEX_INIT(x)             lockinit(&(x),"proplib",0,LK_CANRECURSE)
 294 #define _PROP_MUTEX_LOCK(x)             lockmgr(&(x), LK_EXCLUSIVE)
 295 #define _PROP_MUTEX_UNLOCK(x)           lockmgr(&(x), LK_RELEASE)
 296
 297 #define _PROP_RWLOCK_DECL(x)            struct mtx x;
 298 #define _PROP_RWLOCK_INIT(x)            mtx_init(&(x), "prop")
 299 #define _PROP_RWLOCK_RDLOCK(x)          mtx_lock(&(x))
 300 #define _PROP_RWLOCK_WRLOCK(x)          mtx_lock(&(x))
 301 #define _PROP_RWLOCK_UNLOCK(x)          mtx_unlock(&(x))
 302 #define _PROP_RWLOCK_DESTROY(x)         mtx_uninit(&(x))
 303
 304 #define _PROP_ONCE_DECL(x)              static int x = 0;
 305 #define _PROP_ONCE_RUN(x,f)             if (atomic_cmpset_int(&(x), 0, 1)) f()
 306
 307 #elif defined(_STANDALONE)
 308
 309 /*
 310  * proplib in a standalone environment...
 311  */
 312
 313 #include <lib/libsa/stand.h>
 314
 315 void *          _prop_standalone_calloc(size_t);
 316 void *          _prop_standalone_realloc(void *, size_t);
 317
 318 #define _PROP_ASSERT(x)                 /* nothing */
 319
 320 #define _PROP_MALLOC(s, t)              alloc((s))
 321 #define _PROP_CALLOC(s, t)              _prop_standalone_calloc((s))
 322 #define _PROP_REALLOC(v, s, t)          _prop_standalone_realloc((v), (s))
 323 #define _PROP_FREE(v, t)                dealloc((v), 0)         /* XXX */
 324
 325 #define _PROP_POOL_GET(p)               alloc((p))
 326 #define _PROP_POOL_PUT(p, v)            dealloc((v), (p))
 327
 328 #define _PROP_POOL_INIT(p, s, d)        static const size_t p = s;
 329
 330 #define _PROP_MALLOC_DEFINE(t, s, l)    /* nothing */
 331
 332 #define _PROP_MUTEX_DECL_STATIC(x)      /* nothing */
 333 #define _PROP_MUTEX_INIT(x)             /* nothing */
 334 #define _PROP_MUTEX_LOCK(x)             /* nothing */
 335 #define _PROP_MUTEX_UNLOCK(x)           /* nothing */
 336
 337 #define _PROP_RWLOCK_DECL(x)            /* nothing */
 338 #define _PROP_RWLOCK_INIT(x)            /* nothing */
 339 #define _PROP_RWLOCK_RDLOCK(x)          /* nothing */
 340 #define _PROP_RWLOCK_WRLOCK(x)          /* nothing */
 341 #define _PROP_RWLOCK_UNLOCK(x)          /* nothing */
 342 #define _PROP_RWLOCK_DESTROY(x)         /* nothing */
 343
 344 #define _PROP_ONCE_DECL(x)              _PROP_NOTHREAD_ONCE_DECL(x)
 345 #define _PROP_ONCE_RUN(x,f)             _PROP_NOTHREAD_ONCE_RUN(x,f)
 346
 347 #else
 348
 349 /*
 350  * proplib in user space...
 351  */
 352
 353 #include <assert.h>
 354 #include <string.h>
 355 #include <stdio.h>
 356 #include <stdlib.h>
 357 #include <stddef.h>
 358
 359 #define _PROP_ASSERT(x)                 /*LINTED*/assert(x)
 360
 361 #define _PROP_MALLOC(s, t)              malloc((s))
 362 #define _PROP_CALLOC(s, t)              calloc(1, (s))
 363 #define _PROP_REALLOC(v, s, t)          realloc((v), (s))
 364 #define _PROP_FREE(v, t)                free((v))
 365
 366 #define _PROP_POOL_GET(p)               malloc((p))
 367 #define _PROP_POOL_PUT(p, v)            free((v))
 368
 369 #define _PROP_POOL_INIT(p, s, d)        static const size_t p = s;
 370
 371 #define _PROP_MALLOC_DEFINE(t, s, l)    /* nothing */
 372
 373 #if defined(__NetBSD__) && defined(_LIBPROP)
 374 /*
 375  * Use the same mechanism as libc; we get pthread mutexes for threaded
 376  * programs and do-nothing stubs for non-threaded programs.
 377  */
 378 #include "reentrant.h"
 379 #define _PROP_MUTEX_DECL_STATIC(x)      static mutex_t x;
 380 #define _PROP_MUTEX_INIT(x)             mutex_init(&(x), NULL)
 381 #define _PROP_MUTEX_LOCK(x)             mutex_lock(&(x))
 382 #define _PROP_MUTEX_UNLOCK(x)           mutex_unlock(&(x))
 383
 384 #define _PROP_RWLOCK_DECL(x)            rwlock_t x ;
 385 #define _PROP_RWLOCK_INIT(x)            rwlock_init(&(x), NULL)
 386 #define _PROP_RWLOCK_RDLOCK(x)          rwlock_rdlock(&(x))
 387 #define _PROP_RWLOCK_WRLOCK(x)          rwlock_wrlock(&(x))
 388 #define _PROP_RWLOCK_UNLOCK(x)          rwlock_unlock(&(x))
 389 #define _PROP_RWLOCK_DESTROY(x)         rwlock_destroy(&(x))
 390
 391 #define _PROP_ONCE_DECL(x)                                              \
 392         static pthread_once_t x = PTHREAD_ONCE_INIT;
 393 #define _PROP_ONCE_RUN(x,f)             thr_once(&(x), (void(*)(void))f);
 394
 395 #elif defined(HAVE_NBTOOL_CONFIG_H)
 396 /*
 397  * None of NetBSD's build tools are multi-threaded.
 398  */
 399 #define _PROP_MUTEX_DECL_STATIC(x)      /* nothing */
 400 #define _PROP_MUTEX_INIT(x)             /* nothing */
 401 #define _PROP_MUTEX_LOCK(x)             /* nothing */
 402 #define _PROP_MUTEX_UNLOCK(x)           /* nothing */
 403
 404 #define _PROP_RWLOCK_DECL(x)            /* nothing */
 405 #define _PROP_RWLOCK_INIT(x)            /* nothing */
 406 #define _PROP_RWLOCK_RDLOCK(x)          /* nothing */
 407 #define _PROP_RWLOCK_WRLOCK(x)          /* nothing */
 408 #define _PROP_RWLOCK_UNLOCK(x)          /* nothing */
 409 #define _PROP_RWLOCK_DESTROY(x)         /* nothing */
 410
 411 #define _PROP_ONCE_DECL(x)              _PROP_NOTHREAD_ONCE_DECL(x)
 412 #define _PROP_ONCE_RUN(x,f)             _PROP_NOTHREAD_ONCE_RUN(x,f)
 413 #else
 414 /*
 415  * Use pthread mutexes everywhere else.
 416  */
 417 #include <pthread.h>
 418 #define _PROP_MUTEX_DECL_STATIC(x)      static pthread_mutex_t x;
 419 #define _PROP_MUTEX_INIT(x)             pthread_mutex_init(&(x), NULL)
 420 #define _PROP_MUTEX_LOCK(x)             pthread_mutex_lock(&(x))
 421 #define _PROP_MUTEX_UNLOCK(x)           pthread_mutex_unlock(&(x))
 422
 423 #define _PROP_RWLOCK_DECL(x)            pthread_rwlock_t x ;
 424 #define _PROP_RWLOCK_INIT(x)            pthread_rwlock_init(&(x), NULL)
 425 #define _PROP_RWLOCK_RDLOCK(x)          pthread_rwlock_rdlock(&(x))
 426 #define _PROP_RWLOCK_WRLOCK(x)          pthread_rwlock_wrlock(&(x))
 427 #define _PROP_RWLOCK_UNLOCK(x)          pthread_rwlock_unlock(&(x))
 428 #define _PROP_RWLOCK_DESTROY(x)         pthread_rwlock_destroy(&(x))
 429
 430 #define _PROP_ONCE_DECL(x)                                              \
 431         static pthread_once_t x = PTHREAD_ONCE_INIT;
 432 #define _PROP_ONCE_RUN(x,f)             pthread_once(&(x),(void(*)(void))f)
 433 #endif
 434
 435 #endif /* _KERNEL */
 436
 437 /*
 438  * Language features.
 439  */
 440 #include <sys/cdefs.h>
 441 #define _PROP_ARG_UNUSED                __unused
 442
 443 #endif /* _PROPLIB_PROP_OBJECT_IMPL_H_ */