src/hb-blob.c

   1 /*
   2  * Copyright (C) 2009  Red Hat, Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Red Hat Author(s): Behdad Esfahbod
  25  */
  26
  27 #include "hb-private.h"
  28
  29 #include "hb-blob.h"
  30
  31 #ifdef HAVE_SYS_MMAN_H
  32 #ifdef HAVE_UNISTD_H
  33 #include <unistd.h>
  34 #endif /* HAVE_UNISTD_H */
  35 #include <sys/mman.h>
  36 #endif /* HAVE_SYS_MMAN_H */
  37
  38 #ifndef HB_DEBUG_BLOB
  39 #define HB_DEBUG_BLOB HB_DEBUG
  40 #endif
  41
  42 #if HB_DEBUG_BLOB
  43 #include <stdio.h>
  44 #include <errno.h>
  45 #endif
  46
  47 struct _hb_blob_t {
  48   hb_reference_count_t ref_count;
  49
  50   unsigned int length;
  51
  52   hb_mutex_t lock;
  53   /* the rest are protected by lock */
  54
  55   unsigned int lock_count;
  56   hb_memory_mode_t mode;
  57
  58   const char *data;
  59
  60   hb_destroy_func_t destroy;
  61   void *user_data;
  62 };
  63 static hb_blob_t _hb_blob_nil = {
  64   HB_REFERENCE_COUNT_INVALID, /* ref_count */
  65
  66   0, /* length */
  67
  68   HB_MUTEX_INIT, /* lock */
  69
  70   0, /* lock_count */
  71   HB_MEMORY_MODE_READONLY, /* mode */
  72
  73   NULL, /* data */
  74
  75   NULL, /* destroy */
  76   NULL /* user_data */
  77 };
  78
  79 static void
  80 _hb_blob_destroy_user_data (hb_blob_t *blob)
  81 {
  82   if (blob->destroy) {
  83     blob->destroy (blob->user_data);
  84     blob->destroy = NULL;
  85     blob->user_data = NULL;
  86   }
  87 }
  88
  89 static void
  90 _hb_blob_unlock_and_destroy (hb_blob_t *blob)
  91 {
  92   hb_blob_unlock (blob);
  93   hb_blob_destroy (blob);
  94 }
  95
  96 hb_blob_t *
  97 hb_blob_create (const char        *data,
  98                 unsigned int       length,
  99                 hb_memory_mode_t   mode,
 100                 hb_destroy_func_t  destroy,
 101                 void              *user_data)
 102 {
 103   hb_blob_t *blob;
 104
 105   if (!length || !HB_OBJECT_DO_CREATE (hb_blob_t, blob)) {
 106     if (destroy)
 107       destroy (user_data);
 108     return &_hb_blob_nil;
 109   }
 110
 111   hb_mutex_init (blob->lock);
 112   blob->lock_count = 0;
 113
 114   blob->data = data;
 115   blob->length = length;
 116   blob->mode = mode;
 117
 118   blob->destroy = destroy;
 119   blob->user_data = user_data;
 120
 121   if (blob->mode == HB_MEMORY_MODE_DUPLICATE) {
 122     blob->mode = HB_MEMORY_MODE_READONLY;
 123     if (!hb_blob_try_writable (blob)) {
 124       hb_blob_destroy (blob);
 125       return &_hb_blob_nil;
 126     }
 127   }
 128
 129   return blob;
 130 }
 131
 132 hb_blob_t *
 133 hb_blob_create_sub_blob (hb_blob_t    *parent,
 134                          unsigned int  offset,
 135                          unsigned int  length)
 136 {
 137   hb_blob_t *blob;
 138   const char *pdata;
 139
 140   if (!length || offset >= parent->length || !HB_OBJECT_DO_CREATE (hb_blob_t, blob))
 141     return &_hb_blob_nil;
 142
 143   pdata = hb_blob_lock (parent);
 144
 145   blob->data = pdata + offset;
 146   blob->length = MIN (length, parent->length - offset);
 147
 148   hb_mutex_lock (parent->lock);
 149   blob->mode = parent->mode;
 150   hb_mutex_unlock (parent->lock);
 151
 152   blob->destroy = (hb_destroy_func_t) _hb_blob_unlock_and_destroy;
 153   blob->user_data = hb_blob_reference (parent);
 154
 155   return blob;
 156 }
 157
 158 hb_blob_t *
 159 hb_blob_create_empty (void)
 160 {
 161   return &_hb_blob_nil;
 162 }
 163
 164 hb_blob_t *
 165 hb_blob_reference (hb_blob_t *blob)
 166 {
 167   HB_OBJECT_DO_REFERENCE (blob);
 168 }
 169
 170 unsigned int
 171 hb_blob_get_reference_count (hb_blob_t *blob)
 172 {
 173   HB_OBJECT_DO_GET_REFERENCE_COUNT (blob);
 174 }
 175
 176 void
 177 hb_blob_destroy (hb_blob_t *blob)
 178 {
 179   HB_OBJECT_DO_DESTROY (blob);
 180
 181   _hb_blob_destroy_user_data (blob);
 182
 183   free (blob);
 184 }
 185
 186 unsigned int
 187 hb_blob_get_length (hb_blob_t *blob)
 188 {
 189   return blob->length;
 190 }
 191
 192 const char *
 193 hb_blob_lock (hb_blob_t *blob)
 194 {
 195   if (HB_OBJECT_IS_INERT (blob))
 196     return NULL;
 197
 198   hb_mutex_lock (blob->lock);
 199
 200 #if HB_DEBUG_BLOB
 201   fprintf (stderr, "%p %s (%d) -> %p\n", blob, __FUNCTION__,
 202            blob->lock_count, blob->data);
 203 #endif
 204
 205   blob->lock_count++;
 206
 207   hb_mutex_unlock (blob->lock);
 208
 209   return blob->data;
 210 }
 211
 212 void
 213 hb_blob_unlock (hb_blob_t *blob)
 214 {
 215   if (HB_OBJECT_IS_INERT (blob))
 216     return;
 217
 218   hb_mutex_lock (blob->lock);
 219
 220 #if HB_DEBUG_BLOB
 221   fprintf (stderr, "%p %s (%d) -> %p\n", blob, __FUNCTION__,
 222            blob->lock_count, blob->data);
 223 #endif
 224
 225   assert (blob->lock_count > 0);
 226   blob->lock_count--;
 227
 228   hb_mutex_unlock (blob->lock);
 229 }
 230
 231 hb_bool_t
 232 hb_blob_is_writable (hb_blob_t *blob)
 233 {
 234   hb_memory_mode_t mode;
 235
 236   if (HB_OBJECT_IS_INERT (blob))
 237     return FALSE;
 238
 239   hb_mutex_lock (blob->lock);
 240
 241   mode = blob->mode;
 242
 243   hb_mutex_unlock (blob->lock);
 244
 245   return mode == HB_MEMORY_MODE_WRITABLE;
 246 }
 247
 248
 249 static hb_bool_t
 250 _try_make_writable_inplace_unix_locked (hb_blob_t *blob)
 251 {
 252 #if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MPROTECT)
 253   uintptr_t pagesize = -1, mask, length;
 254   const char *addr;
 255
 256 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
 257   pagesize = (uintptr_t) sysconf (_SC_PAGE_SIZE);
 258 #elif defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
 259   pagesize = (uintptr_t) sysconf (_SC_PAGESIZE);
 260 #elif defined(HAVE_GETPAGESIZE)
 261   pagesize = (uintptr_t) getpagesize ();
 262 #endif
 263
 264   if ((uintptr_t) -1L == pagesize) {
 265 #if HB_DEBUG_BLOB
 266     fprintf (stderr, "%p %s: failed to get pagesize: %s\n", blob, __FUNCTION__, strerror (errno));
 267 #endif
 268     return FALSE;
 269   }
 270 #if HB_DEBUG_BLOB
 271   fprintf (stderr, "%p %s: pagesize is %u\n", blob, __FUNCTION__, pagesize);
 272 #endif
 273
 274   mask = ~(pagesize-1);
 275   addr = (const char *) (((uintptr_t) blob->data) & mask);
 276   length = (const char *) (((uintptr_t) blob->data + blob->length + pagesize-1) & mask)  - addr;
 277 #if HB_DEBUG_BLOB
 278   fprintf (stderr, "%p %s: calling mprotect on [%p..%p] (%d bytes)\n",
 279            blob, __FUNCTION__,
 280            addr, addr+length, length);
 281 #endif
 282   if (-1 == mprotect ((void *) addr, length, PROT_READ | PROT_WRITE)) {
 283 #if HB_DEBUG_BLOB
 284     fprintf (stderr, "%p %s: %s\n", blob, __FUNCTION__, strerror (errno));
 285 #endif
 286     return FALSE;
 287   }
 288
 289 #if HB_DEBUG_BLOB
 290   fprintf (stderr, "%p %s: successfully made [%p..%p] (%d bytes) writable\n",
 291            blob, __FUNCTION__,
 292            addr, addr+length, length);
 293 #endif
 294   return TRUE;
 295 #else
 296   return FALSE;
 297 #endif
 298 }
 299
 300 static void
 301 _try_writable_inplace_locked (hb_blob_t *blob)
 302 {
 303 #if HB_DEBUG_BLOB
 304   fprintf (stderr, "%p %s: making writable\n", blob, __FUNCTION__);
 305 #endif
 306
 307   if (_try_make_writable_inplace_unix_locked (blob)) {
 308 #if HB_DEBUG_BLOB
 309     fprintf (stderr, "%p %s: making writable -> succeeded\n", blob, __FUNCTION__);
 310 #endif
 311     blob->mode = HB_MEMORY_MODE_WRITABLE;
 312   } else {
 313 #if HB_DEBUG_BLOB
 314     fprintf (stderr, "%p %s: making writable -> FAILED\n", blob, __FUNCTION__);
 315 #endif
 316     /* Failed to make writable inplace, mark that */
 317     blob->mode = HB_MEMORY_MODE_READONLY;
 318   }
 319 }
 320
 321 hb_bool_t
 322 hb_blob_try_writable_inplace (hb_blob_t *blob)
 323 {
 324   hb_memory_mode_t mode;
 325
 326   if (HB_OBJECT_IS_INERT (blob))
 327     return FALSE;
 328
 329   hb_mutex_lock (blob->lock);
 330
 331   if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE)
 332     _try_writable_inplace_locked (blob);
 333
 334   mode = blob->mode;
 335
 336   hb_mutex_unlock (blob->lock);
 337
 338   return mode == HB_MEMORY_MODE_WRITABLE;
 339 }
 340
 341 hb_bool_t
 342 hb_blob_try_writable (hb_blob_t *blob)
 343 {
 344   hb_memory_mode_t mode;
 345
 346   if (HB_OBJECT_IS_INERT (blob))
 347     return FALSE;
 348
 349   hb_mutex_lock (blob->lock);
 350
 351   if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE)
 352     _try_writable_inplace_locked (blob);
 353
 354   if (blob->mode == HB_MEMORY_MODE_READONLY)
 355   {
 356     char *new_data;
 357
 358 #if HB_DEBUG_BLOB
 359     fprintf (stderr, "%p %s (%d) -> %p\n", blob, __FUNCTION__,
 360              blob->lock_count, blob->data);
 361 #endif
 362
 363     if (blob->lock_count)
 364       goto done;
 365
 366     new_data = malloc (blob->length);
 367     if (new_data) {
 368 #if HB_DEBUG_BLOB
 369       fprintf (stderr, "%p %s: dupped successfully -> %p\n", blob, __FUNCTION__, blob->data);
 370 #endif
 371       memcpy (new_data, blob->data, blob->length);
 372       _hb_blob_destroy_user_data (blob);
 373       blob->mode = HB_MEMORY_MODE_WRITABLE;
 374       blob->data = new_data;
 375       blob->destroy = free;
 376       blob->user_data = new_data;
 377     }
 378   }
 379
 380 done:
 381   mode = blob->mode;
 382
 383   hb_mutex_unlock (blob->lock);
 384
 385   return mode == HB_MEMORY_MODE_WRITABLE;
 386 }