1 /* $NetBSD: citrus_mapper_std.c,v 1.8 2006/09/11 13:06:33 tnozaki Exp $ */ 2 3 /*- 4 * Copyright (c)2003, 2006 Citrus Project, 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 #if defined(LIBC_SCCS) && !defined(lint) 31 __RCSID("$NetBSD: citrus_mapper_std.c,v 1.8 2006/09/11 13:06:33 tnozaki Exp $"); 32 #endif /* LIBC_SCCS and not lint */ 33 34 #include <assert.h> 35 #include <errno.h> 36 #include <limits.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <stdint.h> 40 #include <string.h> 41 #include <machine/endian.h> 42 #include <sys/queue.h> 43 44 #include "citrus_namespace.h" 45 #include "citrus_types.h" 46 #include "citrus_bcs.h" 47 #include "citrus_region.h" 48 #include "citrus_mmap.h" 49 #include "citrus_module.h" 50 #include "citrus_hash.h" 51 #include "citrus_mapper.h" 52 #include "citrus_db.h" 53 #include "citrus_db_hash.h" 54 55 #include "citrus_mapper_std.h" 56 #include "citrus_mapper_std_file.h" 57 58 /* ---------------------------------------------------------------------- */ 59 60 _CITRUS_MAPPER_DECLS(mapper_std); 61 _CITRUS_MAPPER_DEF_OPS(mapper_std); 62 63 64 /* ---------------------------------------------------------------------- */ 65 66 int 67 _citrus_mapper_std_mapper_getops(struct _citrus_mapper_ops *ops, size_t lenops, 68 u_int32_t expected_version) 69 { 70 if (expected_version<_CITRUS_MAPPER_ABI_VERSION || lenops<sizeof(*ops)) 71 return (EINVAL); 72 73 memcpy(ops, &_citrus_mapper_std_mapper_ops, 74 sizeof(_citrus_mapper_std_mapper_ops)); 75 76 return (0); 77 } 78 79 /* ---------------------------------------------------------------------- */ 80 81 static int 82 /*ARGSUSED*/ 83 rowcol_convert(struct _citrus_mapper_std * __restrict ms, 84 _index_t * __restrict dst, _index_t src, 85 void * __restrict ps) 86 { 87 struct _citrus_mapper_std_rowcol *rc; 88 size_t i; 89 struct _citrus_mapper_std_linear_zone *lz; 90 _index_t n, idx = 0; 91 u_int32_t conv; 92 93 _DIAGASSERT(ms != NULL); 94 _DIAGASSERT(dst != NULL); 95 /* ps may be unused */ 96 rc = &ms->ms_rowcol; 97 98 for (i = rc->rc_src_rowcol_len * rc->rc_src_rowcol_bits, 99 lz = &rc->rc_src_rowcol[0]; i > 0; ++lz) { 100 i -= rc->rc_src_rowcol_bits; 101 n = (src >> i) & rc->rc_src_rowcol_mask; 102 if (n < lz->begin || n > lz->end) { 103 switch (rc->rc_oob_mode) { 104 case _CITRUS_MAPPER_STD_OOB_NONIDENTICAL: 105 *dst = rc->rc_dst_invalid; 106 return _MAPPER_CONVERT_NONIDENTICAL; 107 case _CITRUS_MAPPER_STD_OOB_ILSEQ: 108 return _MAPPER_CONVERT_ILSEQ; 109 default: 110 return _MAPPER_CONVERT_FATAL; 111 } 112 } 113 idx = idx * lz->width + n - lz->begin; 114 } 115 switch (rc->rc_dst_unit_bits) { 116 case 8: 117 conv = _region_peek8(&rc->rc_table, idx); 118 break; 119 case 16: 120 conv = be16toh(_region_peek16(&rc->rc_table, idx*2)); 121 break; 122 case 32: 123 conv = be32toh(_region_peek32(&rc->rc_table, idx*4)); 124 break; 125 default: 126 return _MAPPER_CONVERT_FATAL; 127 } 128 129 if (conv == rc->rc_dst_invalid) { 130 *dst = rc->rc_dst_invalid; 131 return _MAPPER_CONVERT_NONIDENTICAL; 132 } 133 if (conv == rc->rc_dst_ilseq) 134 return _MAPPER_CONVERT_ILSEQ; 135 136 *dst = conv; 137 138 return _MAPPER_CONVERT_SUCCESS; 139 } 140 141 static __inline int 142 set_linear_zone(struct _citrus_mapper_std_linear_zone *lz, 143 u_int32_t begin, u_int32_t end) 144 { 145 _DIAGASSERT(lz != NULL); 146 147 if (begin > end) 148 return EFTYPE; 149 150 lz->begin = begin; 151 lz->end = end; 152 lz->width= end - begin + 1; 153 154 return 0; 155 } 156 157 static __inline int 158 rowcol_parse_variable_compat(struct _citrus_mapper_std_rowcol *rc, 159 struct _region *r) 160 { 161 const struct _citrus_mapper_std_rowcol_info_compat_x *rcx; 162 struct _citrus_mapper_std_linear_zone *lz; 163 u_int32_t m, n; 164 int ret; 165 166 _DIAGASSERT(rc != NULL); 167 _DIAGASSERT(r != NULL && _region_size(r) == sizeof(*rcx)); 168 rcx = _region_head(r); 169 170 rc->rc_dst_invalid = be32toh(rcx->rcx_dst_invalid); 171 rc->rc_dst_unit_bits = be32toh(rcx->rcx_dst_unit_bits); 172 m = be32toh(rcx->rcx_src_col_bits); 173 n = 1 << (m - 1); 174 n |= n - 1; 175 rc->rc_src_rowcol_bits = m; 176 rc->rc_src_rowcol_mask = n; 177 178 rc->rc_src_rowcol = malloc(2 * 179 sizeof(*rc->rc_src_rowcol)); 180 if (rc->rc_src_rowcol == NULL) 181 return ENOMEM; 182 lz = rc->rc_src_rowcol; 183 rc->rc_src_rowcol_len = 1; 184 m = be32toh(rcx->rcx_src_row_begin); 185 n = be32toh(rcx->rcx_src_row_end); 186 if (m + n > 0) { 187 ret = set_linear_zone(lz, m, n); 188 if (ret != 0) 189 return ret; 190 ++rc->rc_src_rowcol_len, ++lz; 191 } 192 m = be32toh(rcx->rcx_src_col_begin); 193 n = be32toh(rcx->rcx_src_col_end); 194 195 return set_linear_zone(lz, m, n); 196 } 197 198 static __inline int 199 rowcol_parse_variable(struct _citrus_mapper_std_rowcol *rc, 200 struct _region *r) 201 { 202 const struct _citrus_mapper_std_rowcol_info_x *rcx; 203 struct _citrus_mapper_std_linear_zone *lz; 204 u_int32_t m, n; 205 size_t i; 206 int ret; 207 208 _DIAGASSERT(rc != NULL); 209 _DIAGASSERT(r != NULL && _region_size(r) == sizeof(*rcx)); 210 rcx = _region_head(r); 211 212 rc->rc_dst_invalid = be32toh(rcx->rcx_dst_invalid); 213 rc->rc_dst_unit_bits = be32toh(rcx->rcx_dst_unit_bits); 214 215 m = be32toh(rcx->rcx_src_rowcol_bits); 216 n = 1 << (m - 1); 217 n |= n - 1; 218 rc->rc_src_rowcol_bits = m; 219 rc->rc_src_rowcol_mask = n; 220 221 rc->rc_src_rowcol_len = be32toh(rcx->rcx_src_rowcol_len); 222 if (rc->rc_src_rowcol_len > _CITRUS_MAPPER_STD_ROWCOL_MAX) 223 return EFTYPE; 224 rc->rc_src_rowcol = malloc(rc->rc_src_rowcol_len * 225 sizeof(*rc->rc_src_rowcol)); 226 if (rc->rc_src_rowcol == NULL) 227 return ENOMEM; 228 for (i = 0, lz = rc->rc_src_rowcol; 229 i < rc->rc_src_rowcol_len; ++i, ++lz) { 230 m = be32toh(rcx->rcx_src_rowcol[i].begin), 231 n = be32toh(rcx->rcx_src_rowcol[i].end); 232 ret = set_linear_zone(lz, m, n); 233 if (ret != 0) { 234 free(rc->rc_src_rowcol); 235 rc->rc_src_rowcol = NULL; 236 return ret; 237 } 238 } 239 return 0; 240 } 241 242 static void 243 rowcol_uninit(struct _citrus_mapper_std *ms) 244 { 245 struct _citrus_mapper_std_rowcol *rc; 246 _DIAGASSERT(ms != NULL); 247 248 rc = &ms->ms_rowcol; 249 free(rc->rc_src_rowcol); 250 } 251 252 static int 253 rowcol_init(struct _citrus_mapper_std *ms) 254 { 255 int ret; 256 struct _citrus_mapper_std_rowcol *rc; 257 const struct _citrus_mapper_std_rowcol_ext_ilseq_info_x *eix; 258 struct _region r; 259 u_int64_t table_size; 260 size_t i; 261 struct _citrus_mapper_std_linear_zone *lz; 262 263 _DIAGASSERT(ms != NULL); 264 ms->ms_convert = &rowcol_convert; 265 ms->ms_uninit = &rowcol_uninit; 266 rc = &ms->ms_rowcol; 267 268 /* get table region */ 269 ret = _db_lookup_by_s(ms->ms_db, _CITRUS_MAPPER_STD_SYM_TABLE, 270 &rc->rc_table, NULL); 271 if (ret) { 272 if (ret==ENOENT) 273 ret = EFTYPE; 274 return ret; 275 } 276 277 /* get table information */ 278 ret = _db_lookup_by_s(ms->ms_db, _CITRUS_MAPPER_STD_SYM_INFO, &r, NULL); 279 if (ret) { 280 if (ret==ENOENT) 281 ret = EFTYPE; 282 return ret; 283 } 284 switch (_region_size(&r)) { 285 case _CITRUS_MAPPER_STD_ROWCOL_INFO_COMPAT_SIZE: 286 ret = rowcol_parse_variable_compat(rc, &r); 287 break; 288 case _CITRUS_MAPPER_STD_ROWCOL_INFO_SIZE: 289 ret = rowcol_parse_variable(rc, &r); 290 break; 291 default: 292 return EFTYPE; 293 } 294 if (ret != 0) 295 return ret; 296 /* sanity check */ 297 switch (rc->rc_src_rowcol_bits) { 298 case 8: case 16: case 32: 299 if (rc->rc_src_rowcol_len <= 32 / rc->rc_src_rowcol_bits) 300 break; 301 /*FALLTHROUGH*/ 302 default: 303 return EFTYPE; 304 } 305 306 /* ilseq extension */ 307 rc->rc_oob_mode = _CITRUS_MAPPER_STD_OOB_NONIDENTICAL; 308 rc->rc_dst_ilseq = rc->rc_dst_invalid; 309 ret = _db_lookup_by_s(ms->ms_db, 310 _CITRUS_MAPPER_STD_SYM_ROWCOL_EXT_ILSEQ, 311 &r, NULL); 312 if (ret && ret != ENOENT) 313 return ret; 314 if (_region_size(&r) < sizeof(*eix)) 315 return EFTYPE; 316 if (ret == 0) { 317 eix = _region_head(&r); 318 rc->rc_oob_mode = be32toh(eix->eix_oob_mode); 319 rc->rc_dst_ilseq = be32toh(eix->eix_dst_ilseq); 320 } 321 322 /* calcurate expected table size */ 323 i = rc->rc_src_rowcol_len; 324 lz = &rc->rc_src_rowcol[--i]; 325 table_size = lz->width; 326 while (i > 0) { 327 lz = &rc->rc_src_rowcol[--i]; 328 table_size *= lz->width; 329 } 330 table_size *= rc->rc_dst_unit_bits/8; 331 332 if (table_size > UINT32_MAX || 333 _region_size(&rc->rc_table) < table_size) 334 return EFTYPE; 335 336 return 0; 337 } 338 339 typedef int (*initfunc_t)(struct _citrus_mapper_std *); 340 static const struct { 341 const char *t_name; 342 initfunc_t t_init; 343 } types[] = { 344 { _CITRUS_MAPPER_STD_TYPE_ROWCOL, &rowcol_init }, 345 }; 346 #define NUM_OF_TYPES ((int)(sizeof(types)/sizeof(types[0]))) 347 348 static int 349 /*ARGSUSED*/ 350 _citrus_mapper_std_mapper_init(struct _citrus_mapper_area *__restrict ma, 351 struct _citrus_mapper * __restrict cm, 352 const char * __restrict curdir, 353 const void * __restrict var, size_t lenvar, 354 struct _citrus_mapper_traits * __restrict mt, 355 size_t lenmt) 356 { 357 char path[PATH_MAX]; 358 const char *type; 359 int ret, id; 360 struct _citrus_mapper_std *ms; 361 362 /* set traits */ 363 if (lenmt<sizeof(*mt)) { 364 ret = EINVAL; 365 goto err0; 366 } 367 mt->mt_src_max = mt->mt_dst_max = 1; /* 1:1 converter */ 368 mt->mt_state_size = 0; /* stateless */ 369 370 /* alloc mapper std structure */ 371 ms = malloc(sizeof(*ms)); 372 if (ms==NULL) { 373 ret = errno; 374 goto err0; 375 } 376 377 /* open mapper file */ 378 snprintf(path, sizeof(path), 379 "%s/%.*s", curdir, (int)lenvar, (const char *)var); 380 ret = _map_file(&ms->ms_file, path); 381 if (ret) 382 goto err1; 383 384 ret = _db_open(&ms->ms_db, &ms->ms_file, _CITRUS_MAPPER_STD_MAGIC, 385 &_db_hash_std, NULL); 386 if (ret) 387 goto err2; 388 389 /* get mapper type */ 390 ret = _db_lookupstr_by_s(ms->ms_db, _CITRUS_MAPPER_STD_SYM_TYPE, 391 &type, NULL); 392 if (ret) { 393 if (ret==ENOENT) 394 ret = EFTYPE; 395 goto err3; 396 } 397 for (id=0; id<NUM_OF_TYPES; id++) 398 if (_bcs_strcasecmp(type, types[id].t_name) == 0) 399 break; 400 401 if (id == NUM_OF_TYPES) 402 goto err3; 403 404 /* init the per-type structure */ 405 ret = (*types[id].t_init)(ms); 406 if (ret) 407 goto err3; 408 409 cm->cm_closure = ms; 410 411 return 0; 412 413 err3: 414 _db_close(ms->ms_db); 415 err2: 416 _unmap_file(&ms->ms_file); 417 err1: 418 free(ms); 419 err0: 420 return ret; 421 } 422 423 static void 424 /*ARGSUSED*/ 425 _citrus_mapper_std_mapper_uninit(struct _citrus_mapper *cm) 426 { 427 struct _citrus_mapper_std *ms; 428 429 _DIAGASSERT(cm!=NULL & cm->cm_closure!=NULL); 430 431 ms = cm->cm_closure; 432 if (ms->ms_uninit) 433 (*ms->ms_uninit)(ms); 434 _db_close(ms->ms_db); 435 _unmap_file(&ms->ms_file); 436 free(ms); 437 } 438 439 static void 440 /*ARGSUSED*/ 441 _citrus_mapper_std_mapper_init_state(struct _citrus_mapper * __restrict cm, 442 void * __restrict ps) 443 { 444 } 445 446 static int 447 /*ARGSUSED*/ 448 _citrus_mapper_std_mapper_convert(struct _citrus_mapper * __restrict cm, 449 _index_t * __restrict dst, _index_t src, 450 void * __restrict ps) 451 { 452 struct _citrus_mapper_std *ms; 453 454 _DIAGASSERT(cm!=NULL && cm->cm_closure!=NULL); 455 456 ms = cm->cm_closure; 457 458 _DIAGASSERT(ms->ms_convert != NULL); 459 460 return (*ms->ms_convert)(ms, dst, src, ps); 461 } 462