radeon/bof.c

   1 /*
   2  * Copyright 2010 Jerome Glisse <glisse@freedesktop.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *      Jerome Glisse
  25  */
  26 #include <errno.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include "bof.h"
  30
  31 /*
  32  * helpers
  33  */
  34 static int bof_entry_grow(bof_t *bof)
  35 {
  36         bof_t **array;
  37
  38         if (bof->array_size < bof->nentry)
  39                 return 0;
  40         array = realloc(bof->array, (bof->nentry + 16) * sizeof(void*));
  41         if (array == NULL)
  42                 return -ENOMEM;
  43         bof->array = array;
  44         bof->nentry += 16;
  45         return 0;
  46 }
  47
  48 /*
  49  * object
  50  */
  51 bof_t *bof_object(void)
  52 {
  53         bof_t *object;
  54
  55         object = calloc(1, sizeof(bof_t));
  56         if (object == NULL)
  57                 return NULL;
  58         object->refcount = 1;
  59         object->type = BOF_TYPE_OBJECT;
  60         object->size = 12;
  61         return object;
  62 }
  63
  64 bof_t *bof_object_get(bof_t *object, const char *keyname)
  65 {
  66         unsigned i;
  67
  68         for (i = 0; i < object->array_size; i += 2) {
  69                 if (!strcmp(object->array[i]->value, keyname)) {
  70                         return object->array[i + 1];
  71                 }
  72         }
  73         return NULL;
  74 }
  75
  76 int bof_object_set(bof_t *object, const char *keyname, bof_t *value)
  77 {
  78         bof_t *key;
  79         int r;
  80
  81         if (object->type != BOF_TYPE_OBJECT)
  82                 return -EINVAL;
  83         r = bof_entry_grow(object);
  84         if (r)
  85                 return r;
  86         key = bof_string(keyname);
  87         if (key == NULL)
  88                 return -ENOMEM;
  89         object->array[object->array_size++] = key;
  90         object->array[object->array_size++] = value;
  91         object->size += value->size;
  92         object->size += key->size;
  93         bof_incref(value);
  94         return 0;
  95 }
  96
  97 /*
  98  * array
  99  */
 100 bof_t *bof_array(void)
 101 {
 102         bof_t *array = bof_object();
 103
 104         if (array == NULL)
 105                 return NULL;
 106         array->type = BOF_TYPE_ARRAY;
 107         array->size = 12;
 108         return array;
 109 }
 110
 111 int bof_array_append(bof_t *array, bof_t *value)
 112 {
 113         int r;
 114         if (array->type != BOF_TYPE_ARRAY)
 115                 return -EINVAL;
 116         r = bof_entry_grow(array);
 117         if (r)
 118                 return r;
 119         array->array[array->array_size++] = value;
 120         array->size += value->size;
 121         bof_incref(value);
 122         return 0;
 123 }
 124
 125 bof_t *bof_array_get(bof_t *bof, unsigned i)
 126 {
 127         if (!bof_is_array(bof) || i >= bof->array_size)
 128                 return NULL;
 129         return bof->array[i];
 130 }
 131
 132 unsigned bof_array_size(bof_t *bof)
 133 {
 134         if (!bof_is_array(bof))
 135                 return 0;
 136         return bof->array_size;
 137 }
 138
 139 /*
 140  * blob
 141  */
 142 bof_t *bof_blob(unsigned size, void *value)
 143 {
 144         bof_t *blob = bof_object();
 145
 146         if (blob == NULL)
 147                 return NULL;
 148         blob->type = BOF_TYPE_BLOB;
 149         blob->value = calloc(1, size);
 150         if (blob->value == NULL) {
 151                 bof_decref(blob);
 152                 return NULL;
 153         }
 154         blob->size = size;
 155         memcpy(blob->value, value, size);
 156         blob->size += 12;
 157         return blob;
 158 }
 159
 160 unsigned bof_blob_size(bof_t *bof)
 161 {
 162         if (!bof_is_blob(bof))
 163                 return 0;
 164         return bof->size - 12;
 165 }
 166
 167 void *bof_blob_value(bof_t *bof)
 168 {
 169         if (!bof_is_blob(bof))
 170                 return NULL;
 171         return bof->value;
 172 }
 173
 174 /*
 175  * string
 176  */
 177 bof_t *bof_string(const char *value)
 178 {
 179         bof_t *string = bof_object();
 180
 181         if (string == NULL)
 182                 return NULL;
 183         string->type = BOF_TYPE_STRING;
 184         string->size = strlen(value) + 1;
 185         string->value = calloc(1, string->size);
 186         if (string->value == NULL) {
 187                 bof_decref(string);
 188                 return NULL;
 189         }
 190         strcpy(string->value, value);
 191         string->size += 12;
 192         return string;
 193 }
 194
 195 /*
 196  *  int32
 197  */
 198 bof_t *bof_int32(int32_t value)
 199 {
 200         bof_t *int32 = bof_object();
 201
 202         if (int32 == NULL)
 203                 return NULL;
 204         int32->type = BOF_TYPE_INT32;
 205         int32->size = 4;
 206         int32->value = calloc(1, int32->size);
 207         if (int32->value == NULL) {
 208                 bof_decref(int32);
 209                 return NULL;
 210         }
 211         memcpy(int32->value, &value, 4);
 212         int32->size += 12;
 213         return int32;
 214 }
 215
 216 int32_t bof_int32_value(bof_t *bof)
 217 {
 218         return *((uint32_t*)bof->value);
 219 }
 220
 221 /*
 222  *  common
 223  */
 224 static void bof_indent(int level)
 225 {
 226         int i;
 227
 228         for (i = 0; i < level; i++)
 229                 fprintf(stderr, " ");
 230 }
 231
 232 static void bof_print_bof(bof_t *bof, int level, int entry)
 233 {
 234         bof_indent(level);
 235         if (bof == NULL) {
 236                 fprintf(stderr, "--NULL-- for entry %d\n", entry);
 237                 return;
 238         }
 239         switch (bof->type) {
 240         case BOF_TYPE_STRING:
 241                 fprintf(stderr, "%p string [%s %d]\n", bof, (char*)bof->value, bof->size);
 242                 break;
 243         case BOF_TYPE_INT32:
 244                 fprintf(stderr, "%p int32 [%d %d]\n", bof, *(int*)bof->value, bof->size);
 245                 break;
 246         case BOF_TYPE_BLOB:
 247                 fprintf(stderr, "%p blob [%d]\n", bof, bof->size);
 248                 break;
 249         case BOF_TYPE_NULL:
 250                 fprintf(stderr, "%p null [%d]\n", bof, bof->size);
 251                 break;
 252         case BOF_TYPE_OBJECT:
 253                 fprintf(stderr, "%p object [%d %d]\n", bof, bof->array_size / 2, bof->size);
 254                 break;
 255         case BOF_TYPE_ARRAY:
 256                 fprintf(stderr, "%p array [%d %d]\n", bof, bof->array_size, bof->size);
 257                 break;
 258         default:
 259                 fprintf(stderr, "%p unknown [%d]\n", bof, bof->type);
 260                 return;
 261         }
 262 }
 263
 264 static void bof_print_rec(bof_t *bof, int level, int entry)
 265 {
 266         unsigned i;
 267
 268         bof_print_bof(bof, level, entry);
 269         for (i = 0; i < bof->array_size; i++) {
 270                 bof_print_rec(bof->array[i], level + 2, i);
 271         }
 272 }
 273
 274 void bof_print(bof_t *bof)
 275 {
 276         bof_print_rec(bof, 0, 0);
 277 }
 278
 279 static int bof_read(bof_t *root, FILE *file, long end, int level)
 280 {
 281         bof_t *bof = NULL;
 282         int r;
 283
 284         if (ftell(file) >= end) {
 285                 return 0;
 286         }
 287         r = bof_entry_grow(root);
 288         if (r)
 289                 return r;
 290         bof = bof_object();
 291         if (bof == NULL)
 292                 return -ENOMEM;
 293         bof->offset = ftell(file);
 294         r = fread(&bof->type, 4, 1, file);
 295         if (r != 1)
 296                 goto out_err;
 297         r = fread(&bof->size, 4, 1, file);
 298         if (r != 1)
 299                 goto out_err;
 300         r = fread(&bof->array_size, 4, 1, file);
 301         if (r != 1)
 302                 goto out_err;
 303         switch (bof->type) {
 304         case BOF_TYPE_STRING:
 305         case BOF_TYPE_INT32:
 306         case BOF_TYPE_BLOB:
 307                 bof->value = calloc(1, bof->size - 12);
 308                 if (bof->value == NULL) {
 309                         goto out_err;
 310                 }
 311                 r = fread(bof->value, bof->size - 12, 1, file);
 312                 if (r != 1) {
 313                         fprintf(stderr, "error reading %d\n", bof->size - 12);
 314                         goto out_err;
 315                 }
 316                 break;
 317         case BOF_TYPE_NULL:
 318                 return 0;
 319         case BOF_TYPE_OBJECT:
 320         case BOF_TYPE_ARRAY:
 321                 r = bof_read(bof, file, bof->offset + bof->size, level + 2);
 322                 if (r)
 323                         goto out_err;
 324                 break;
 325         default:
 326                 fprintf(stderr, "invalid type %d\n", bof->type);
 327                 goto out_err;
 328         }
 329         root->array[root->centry++] = bof;
 330         return bof_read(root, file, end, level);
 331 out_err:
 332         bof_decref(bof);
 333         return -EINVAL;
 334 }
 335
 336 bof_t *bof_load_file(const char *filename)
 337 {
 338         bof_t *root = bof_object();
 339         int r;
 340
 341         if (root == NULL) {
 342                 fprintf(stderr, "%s failed to create root object\n", __func__);
 343                 return NULL;
 344         }
 345         root->file = fopen(filename, "r");
 346         if (root->file == NULL)
 347                 goto out_err;
 348         r = fseek(root->file, 0L, SEEK_SET);
 349         if (r) {
 350                 fprintf(stderr, "%s failed to seek into file %s\n", __func__, filename);
 351                 goto out_err;
 352         }
 353         root->offset = ftell(root->file);
 354         r = fread(&root->type, 4, 1, root->file);
 355         if (r != 1)
 356                 goto out_err;
 357         r = fread(&root->size, 4, 1, root->file);
 358         if (r != 1)
 359                 goto out_err;
 360         r = fread(&root->array_size, 4, 1, root->file);
 361         if (r != 1)
 362                 goto out_err;
 363         r = bof_read(root, root->file, root->offset + root->size, 2);
 364         if (r)
 365                 goto out_err;
 366         return root;
 367 out_err:
 368         bof_decref(root);
 369         return NULL;
 370 }
 371
 372 void bof_incref(bof_t *bof)
 373 {
 374         bof->refcount++;
 375 }
 376
 377 void bof_decref(bof_t *bof)
 378 {
 379         unsigned i;
 380
 381         if (bof == NULL)
 382                 return;
 383         if (--bof->refcount > 0)
 384                 return;
 385         for (i = 0; i < bof->array_size; i++) {
 386                 bof_decref(bof->array[i]);
 387                 bof->array[i] = NULL;
 388         }
 389         bof->array_size = 0;
 390         if (bof->file) {
 391                 fclose(bof->file);
 392                 bof->file = NULL;
 393         }
 394         free(bof->array);
 395         free(bof->value);
 396         free(bof);
 397 }
 398
 399 static int bof_file_write(bof_t *bof, FILE *file)
 400 {
 401         unsigned i;
 402         int r;
 403
 404         r = fwrite(&bof->type, 4, 1, file);
 405         if (r != 1)
 406                 return -EINVAL;
 407         r = fwrite(&bof->size, 4, 1, file);
 408         if (r != 1)
 409                 return -EINVAL;
 410         r = fwrite(&bof->array_size, 4, 1, file);
 411         if (r != 1)
 412                 return -EINVAL;
 413         switch (bof->type) {
 414         case BOF_TYPE_NULL:
 415                 if (bof->size)
 416                         return -EINVAL;
 417                 break;
 418         case BOF_TYPE_STRING:
 419         case BOF_TYPE_INT32:
 420         case BOF_TYPE_BLOB:
 421                 r = fwrite(bof->value, bof->size - 12, 1, file);
 422                 if (r != 1)
 423                         return -EINVAL;
 424                 break;
 425         case BOF_TYPE_OBJECT:
 426         case BOF_TYPE_ARRAY:
 427                 for (i = 0; i < bof->array_size; i++) {
 428                         r = bof_file_write(bof->array[i], file);
 429                         if (r)
 430                                 return r;
 431                 }
 432                 break;
 433         default:
 434                 return -EINVAL;
 435         }
 436         return 0;
 437 }
 438
 439 int bof_dump_file(bof_t *bof, const char *filename)
 440 {
 441         unsigned i;
 442         int r = 0;
 443
 444         if (bof->file) {
 445                 fclose(bof->file);
 446                 bof->file = NULL;
 447         }
 448         bof->file = fopen(filename, "w");
 449         if (bof->file == NULL) {
 450                 fprintf(stderr, "%s failed to open file %s\n", __func__, filename);
 451                 r = -EINVAL;
 452                 goto out_err;
 453         }
 454         r = fseek(bof->file, 0L, SEEK_SET);
 455         if (r) {
 456                 fprintf(stderr, "%s failed to seek into file %s\n", __func__, filename);
 457                 goto out_err;
 458         }
 459         r = fwrite(&bof->type, 4, 1, bof->file);
 460         if (r != 1)
 461                 goto out_err;
 462         r = fwrite(&bof->size, 4, 1, bof->file);
 463         if (r != 1)
 464                 goto out_err;
 465         r = fwrite(&bof->array_size, 4, 1, bof->file);
 466         if (r != 1)
 467                 goto out_err;
 468         for (i = 0; i < bof->array_size; i++) {
 469                 r = bof_file_write(bof->array[i], bof->file);
 470                 if (r)
 471                         return r;
 472         }
 473 out_err:
 474         fclose(bof->file);
 475         bof->file = NULL;
 476         return r;
 477 }