1 /* 2 * Copyright 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 /* http://www.oracle.com/technetwork/articles/servers-storage-dev/standardheaderfiles-453865.html */ 28 #ifndef _POSIX_C_SOURCE 29 #define _POSIX_C_SOURCE 199309L 30 #endif 31 32 #include "hb-private.hh" 33 34 #include "hb-object-private.hh" 35 36 #ifdef HAVE_SYS_MMAN_H 37 #ifdef HAVE_UNISTD_H 38 #include <unistd.h> 39 #endif /* HAVE_UNISTD_H */ 40 #include <sys/mman.h> 41 #endif /* HAVE_SYS_MMAN_H */ 42 43 #include <stdio.h> 44 #include <errno.h> 45 46 47 48 #ifndef HB_DEBUG_BLOB 49 #define HB_DEBUG_BLOB (HB_DEBUG+0) 50 #endif 51 52 53 struct hb_blob_t { 54 hb_object_header_t header; 55 ASSERT_POD (); 56 57 bool immutable; 58 59 const char *data; 60 unsigned int length; 61 hb_memory_mode_t mode; 62 63 void *user_data; 64 hb_destroy_func_t destroy; 65 }; 66 67 68 static bool _try_writable (hb_blob_t *blob); 69 70 static void 71 _hb_blob_destroy_user_data (hb_blob_t *blob) 72 { 73 if (blob->destroy) { 74 blob->destroy (blob->user_data); 75 blob->user_data = NULL; 76 blob->destroy = NULL; 77 } 78 } 79 80 /** 81 * hb_blob_create: (skip) 82 * @data: Pointer to blob data. 83 * @length: Length of @data in bytes. 84 * @mode: Memory mode for @data. 85 * @user_data: Data parameter to pass to @destroy. 86 * @destroy: Callback to call when @data is not needed anymore. 87 * 88 * Creates a new "blob" object wrapping @data. The @mode parameter is used 89 * to negotiate ownership and lifecycle of @data. 90 * 91 * Return value: New blob, or the empty blob if something failed or if @length is 92 * zero. Destroy with hb_blob_destroy(). 93 * 94 * Since: 0.9.2 95 **/ 96 hb_blob_t * 97 hb_blob_create (const char *data, 98 unsigned int length, 99 hb_memory_mode_t mode, 100 void *user_data, 101 hb_destroy_func_t destroy) 102 { 103 hb_blob_t *blob; 104 105 if (!length || 106 length >= 1u << 31 || 107 !(blob = hb_object_create<hb_blob_t> ())) { 108 if (destroy) 109 destroy (user_data); 110 return hb_blob_get_empty (); 111 } 112 113 blob->data = data; 114 blob->length = length; 115 blob->mode = mode; 116 117 blob->user_data = user_data; 118 blob->destroy = destroy; 119 120 if (blob->mode == HB_MEMORY_MODE_DUPLICATE) { 121 blob->mode = HB_MEMORY_MODE_READONLY; 122 if (!_try_writable (blob)) { 123 hb_blob_destroy (blob); 124 return hb_blob_get_empty (); 125 } 126 } 127 128 return blob; 129 } 130 131 /** 132 * hb_blob_create_sub_blob: 133 * @parent: Parent blob. 134 * @offset: Start offset of sub-blob within @parent, in bytes. 135 * @length: Length of sub-blob. 136 * 137 * Returns a blob that represents a range of bytes in @parent. The new 138 * blob is always created with %HB_MEMORY_MODE_READONLY, meaning that it 139 * will never modify data in the parent blob. The parent data is not 140 * expected to be modified, and will result in undefined behavior if it 141 * is. 142 * 143 * Makes @parent immutable. 144 * 145 * Return value: New blob, or the empty blob if something failed or if 146 * @length is zero or @offset is beyond the end of @parent's data. Destroy 147 * with hb_blob_destroy(). 148 * 149 * Since: 0.9.2 150 **/ 151 hb_blob_t * 152 hb_blob_create_sub_blob (hb_blob_t *parent, 153 unsigned int offset, 154 unsigned int length) 155 { 156 hb_blob_t *blob; 157 158 if (!length || offset >= parent->length) 159 return hb_blob_get_empty (); 160 161 hb_blob_make_immutable (parent); 162 163 blob = hb_blob_create (parent->data + offset, 164 MIN (length, parent->length - offset), 165 HB_MEMORY_MODE_READONLY, 166 hb_blob_reference (parent), 167 (hb_destroy_func_t) hb_blob_destroy); 168 169 return blob; 170 } 171 172 /** 173 * hb_blob_get_empty: 174 * 175 * Returns the singleton empty blob. 176 * 177 * See TODO:link object types for more information. 178 * 179 * Return value: (transfer full): the empty blob. 180 * 181 * Since: 0.9.2 182 **/ 183 hb_blob_t * 184 hb_blob_get_empty (void) 185 { 186 static const hb_blob_t _hb_blob_nil = { 187 HB_OBJECT_HEADER_STATIC, 188 189 true, /* immutable */ 190 191 NULL, /* data */ 192 0, /* length */ 193 HB_MEMORY_MODE_READONLY, /* mode */ 194 195 NULL, /* user_data */ 196 NULL /* destroy */ 197 }; 198 199 return const_cast<hb_blob_t *> (&_hb_blob_nil); 200 } 201 202 /** 203 * hb_blob_reference: (skip) 204 * @blob: a blob. 205 * 206 * Increases the reference count on @blob. 207 * 208 * See TODO:link object types for more information. 209 * 210 * Return value: @blob. 211 * 212 * Since: 0.9.2 213 **/ 214 hb_blob_t * 215 hb_blob_reference (hb_blob_t *blob) 216 { 217 return hb_object_reference (blob); 218 } 219 220 /** 221 * hb_blob_destroy: (skip) 222 * @blob: a blob. 223 * 224 * Descreases the reference count on @blob, and if it reaches zero, destroys 225 * @blob, freeing all memory, possibly calling the destroy-callback the blob 226 * was created for if it has not been called already. 227 * 228 * See TODO:link object types for more information. 229 * 230 * Since: 0.9.2 231 **/ 232 void 233 hb_blob_destroy (hb_blob_t *blob) 234 { 235 if (!hb_object_destroy (blob)) return; 236 237 _hb_blob_destroy_user_data (blob); 238 239 free (blob); 240 } 241 242 /** 243 * hb_blob_set_user_data: (skip) 244 * @blob: a blob. 245 * @key: key for data to set. 246 * @data: data to set. 247 * @destroy: callback to call when @data is not needed anymore. 248 * @replace: whether to replace an existing data with the same key. 249 * 250 * Return value: 251 * 252 * Since: 0.9.2 253 **/ 254 hb_bool_t 255 hb_blob_set_user_data (hb_blob_t *blob, 256 hb_user_data_key_t *key, 257 void * data, 258 hb_destroy_func_t destroy, 259 hb_bool_t replace) 260 { 261 return hb_object_set_user_data (blob, key, data, destroy, replace); 262 } 263 264 /** 265 * hb_blob_get_user_data: (skip) 266 * @blob: a blob. 267 * @key: key for data to get. 268 * 269 * 270 * 271 * Return value: (transfer none): 272 * 273 * Since: 0.9.2 274 **/ 275 void * 276 hb_blob_get_user_data (hb_blob_t *blob, 277 hb_user_data_key_t *key) 278 { 279 return hb_object_get_user_data (blob, key); 280 } 281 282 283 /** 284 * hb_blob_make_immutable: 285 * @blob: a blob. 286 * 287 * 288 * 289 * Since: 0.9.2 290 **/ 291 void 292 hb_blob_make_immutable (hb_blob_t *blob) 293 { 294 if (hb_object_is_inert (blob)) 295 return; 296 297 blob->immutable = true; 298 } 299 300 /** 301 * hb_blob_is_immutable: 302 * @blob: a blob. 303 * 304 * 305 * 306 * Return value: TODO 307 * 308 * Since: 0.9.2 309 **/ 310 hb_bool_t 311 hb_blob_is_immutable (hb_blob_t *blob) 312 { 313 return blob->immutable; 314 } 315 316 317 /** 318 * hb_blob_get_length: 319 * @blob: a blob. 320 * 321 * 322 * 323 * Return value: the length of blob data in bytes. 324 * 325 * Since: 0.9.2 326 **/ 327 unsigned int 328 hb_blob_get_length (hb_blob_t *blob) 329 { 330 return blob->length; 331 } 332 333 /** 334 * hb_blob_get_data: 335 * @blob: a blob. 336 * @length: (out): 337 * 338 * 339 * 340 * Returns: (transfer none) (array length=length): 341 * 342 * Since: 0.9.2 343 **/ 344 const char * 345 hb_blob_get_data (hb_blob_t *blob, unsigned int *length) 346 { 347 if (length) 348 *length = blob->length; 349 350 return blob->data; 351 } 352 353 /** 354 * hb_blob_get_data_writable: 355 * @blob: a blob. 356 * @length: (out): output length of the writable data. 357 * 358 * Tries to make blob data writable (possibly copying it) and 359 * return pointer to data. 360 * 361 * Fails if blob has been made immutable, or if memory allocation 362 * fails. 363 * 364 * Returns: (transfer none) (array length=length): Writable blob data, 365 * or %NULL if failed. 366 * 367 * Since: 0.9.2 368 **/ 369 char * 370 hb_blob_get_data_writable (hb_blob_t *blob, unsigned int *length) 371 { 372 if (!_try_writable (blob)) { 373 if (length) 374 *length = 0; 375 376 return NULL; 377 } 378 379 if (length) 380 *length = blob->length; 381 382 return const_cast<char *> (blob->data); 383 } 384 385 386 static hb_bool_t 387 _try_make_writable_inplace_unix (hb_blob_t *blob) 388 { 389 #if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MPROTECT) 390 uintptr_t pagesize = -1, mask, length; 391 const char *addr; 392 393 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE) 394 pagesize = (uintptr_t) sysconf (_SC_PAGE_SIZE); 395 #elif defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE) 396 pagesize = (uintptr_t) sysconf (_SC_PAGESIZE); 397 #elif defined(HAVE_GETPAGESIZE) 398 pagesize = (uintptr_t) getpagesize (); 399 #endif 400 401 if ((uintptr_t) -1L == pagesize) { 402 DEBUG_MSG_FUNC (BLOB, blob, "failed to get pagesize: %s", strerror (errno)); 403 return false; 404 } 405 DEBUG_MSG_FUNC (BLOB, blob, "pagesize is %lu", (unsigned long) pagesize); 406 407 mask = ~(pagesize-1); 408 addr = (const char *) (((uintptr_t) blob->data) & mask); 409 length = (const char *) (((uintptr_t) blob->data + blob->length + pagesize-1) & mask) - addr; 410 DEBUG_MSG_FUNC (BLOB, blob, 411 "calling mprotect on [%p..%p] (%lu bytes)", 412 addr, addr+length, (unsigned long) length); 413 if (-1 == mprotect ((void *) addr, length, PROT_READ | PROT_WRITE)) { 414 DEBUG_MSG_FUNC (BLOB, blob, "mprotect failed: %s", strerror (errno)); 415 return false; 416 } 417 418 blob->mode = HB_MEMORY_MODE_WRITABLE; 419 420 DEBUG_MSG_FUNC (BLOB, blob, 421 "successfully made [%p..%p] (%lu bytes) writable\n", 422 addr, addr+length, (unsigned long) length); 423 return true; 424 #else 425 return false; 426 #endif 427 } 428 429 static bool 430 _try_writable_inplace (hb_blob_t *blob) 431 { 432 DEBUG_MSG_FUNC (BLOB, blob, "making writable inplace\n"); 433 434 if (_try_make_writable_inplace_unix (blob)) 435 return true; 436 437 DEBUG_MSG_FUNC (BLOB, blob, "making writable -> FAILED\n"); 438 439 /* Failed to make writable inplace, mark that */ 440 blob->mode = HB_MEMORY_MODE_READONLY; 441 return false; 442 } 443 444 static bool 445 _try_writable (hb_blob_t *blob) 446 { 447 if (blob->immutable) 448 return false; 449 450 if (blob->mode == HB_MEMORY_MODE_WRITABLE) 451 return true; 452 453 if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE && _try_writable_inplace (blob)) 454 return true; 455 456 if (blob->mode == HB_MEMORY_MODE_WRITABLE) 457 return true; 458 459 460 DEBUG_MSG_FUNC (BLOB, blob, "current data is -> %p\n", blob->data); 461 462 char *new_data; 463 464 new_data = (char *) malloc (blob->length); 465 if (unlikely (!new_data)) 466 return false; 467 468 DEBUG_MSG_FUNC (BLOB, blob, "dupped successfully -> %p\n", blob->data); 469 470 memcpy (new_data, blob->data, blob->length); 471 _hb_blob_destroy_user_data (blob); 472 blob->mode = HB_MEMORY_MODE_WRITABLE; 473 blob->data = new_data; 474 blob->user_data = new_data; 475 blob->destroy = free; 476 477 return true; 478 } 479
