Update Copyright headers
[apps/home/video-player.git] / src / hb-blob.cc
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 #include "hb-private.hh"
28
29 #include "hb-blob-private.hh"
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 #include <stdio.h>
39 #include <errno.h>
40
41 HB_BEGIN_DECLS
42
43
44 #ifndef HB_DEBUG_BLOB
45 #define HB_DEBUG_BLOB (HB_DEBUG+0)
46 #endif
47
48 hb_blob_t _hb_blob_nil = {
49   HB_REFERENCE_COUNT_INVALID, /* ref_count */
50
51   0, /* length */
52
53   HB_MUTEX_INIT, /* lock */
54
55   0, /* lock_count */
56   HB_MEMORY_MODE_READONLY, /* mode */
57
58   NULL, /* data */
59
60   NULL, /* user_data */
61   NULL  /* destroy */
62 };
63
64 static void
65 _hb_blob_destroy_user_data (hb_blob_t *blob)
66 {
67   if (blob->destroy) {
68     blob->destroy (blob->user_data);
69     blob->user_data = NULL;
70     blob->destroy = NULL;
71   }
72 }
73
74 static void
75 _hb_blob_unlock_and_destroy (hb_blob_t *blob)
76 {
77   hb_blob_unlock (blob);
78   hb_blob_destroy (blob);
79 }
80
81 hb_blob_t *
82 hb_blob_create (const char        *data,
83                 unsigned int       length,
84                 hb_memory_mode_t   mode,
85                 void              *user_data,
86                 hb_destroy_func_t  destroy)
87 {
88   hb_blob_t *blob;
89
90   if (!length || !HB_OBJECT_DO_CREATE (hb_blob_t, blob)) {
91     if (destroy)
92       destroy (user_data);
93     return &_hb_blob_nil;
94   }
95
96   hb_mutex_init (blob->lock);
97   blob->lock_count = 0;
98
99   blob->data = data;
100   blob->length = length;
101   blob->mode = mode;
102
103   blob->user_data = user_data;
104   blob->destroy = destroy;
105
106   if (blob->mode == HB_MEMORY_MODE_DUPLICATE) {
107     blob->mode = HB_MEMORY_MODE_READONLY;
108     if (!hb_blob_try_writable (blob)) {
109       hb_blob_destroy (blob);
110       return &_hb_blob_nil;
111     }
112   }
113
114   return blob;
115 }
116
117 hb_blob_t *
118 hb_blob_create_sub_blob (hb_blob_t    *parent,
119                          unsigned int  offset,
120                          unsigned int  length)
121 {
122   hb_blob_t *blob;
123   const char *pdata;
124
125   if (!length || offset >= parent->length || !HB_OBJECT_DO_CREATE (hb_blob_t, blob))
126     return &_hb_blob_nil;
127
128   pdata = hb_blob_lock (parent);
129
130   blob->data = pdata + offset;
131   blob->length = MIN (length, parent->length - offset);
132
133   hb_mutex_lock (parent->lock);
134   blob->mode = parent->mode;
135   hb_mutex_unlock (parent->lock);
136
137   blob->user_data = hb_blob_reference (parent);
138   blob->destroy = (hb_destroy_func_t) _hb_blob_unlock_and_destroy;
139
140   return blob;
141 }
142
143 hb_blob_t *
144 hb_blob_create_empty (void)
145 {
146   return &_hb_blob_nil;
147 }
148
149 hb_blob_t *
150 hb_blob_reference (hb_blob_t *blob)
151 {
152   HB_OBJECT_DO_REFERENCE (blob);
153 }
154
155 void
156 hb_blob_destroy (hb_blob_t *blob)
157 {
158   HB_OBJECT_DO_DESTROY (blob);
159
160   _hb_blob_destroy_user_data (blob);
161
162   free (blob);
163 }
164
165 unsigned int
166 hb_blob_get_length (hb_blob_t *blob)
167 {
168   return blob->length;
169 }
170
171 const char *
172 hb_blob_lock (hb_blob_t *blob)
173 {
174   if (HB_OBJECT_IS_INERT (blob))
175     return NULL;
176
177   hb_mutex_lock (blob->lock);
178
179   (void) (HB_DEBUG_BLOB &&
180     fprintf (stderr, "%p %s (%d) -> %p\n", blob, __FUNCTION__,
181              blob->lock_count, blob->data));
182
183   blob->lock_count++;
184
185   hb_mutex_unlock (blob->lock);
186
187   return blob->data;
188 }
189
190 void
191 hb_blob_unlock (hb_blob_t *blob)
192 {
193   if (HB_OBJECT_IS_INERT (blob))
194     return;
195
196   hb_mutex_lock (blob->lock);
197
198   (void) (HB_DEBUG_BLOB &&
199     fprintf (stderr, "%p %s (%d) -> %p\n", blob, __FUNCTION__,
200              blob->lock_count, blob->data));
201
202   assert (blob->lock_count > 0);
203   blob->lock_count--;
204
205   hb_mutex_unlock (blob->lock);
206 }
207
208 hb_bool_t
209 hb_blob_is_writable (hb_blob_t *blob)
210 {
211   hb_memory_mode_t mode;
212
213   if (HB_OBJECT_IS_INERT (blob))
214     return FALSE;
215
216   hb_mutex_lock (blob->lock);
217
218   mode = blob->mode;
219
220   hb_mutex_unlock (blob->lock);
221
222   return mode == HB_MEMORY_MODE_WRITABLE;
223 }
224
225
226 static hb_bool_t
227 _try_make_writable_inplace_unix_locked (hb_blob_t *blob)
228 {
229 #if defined(HAVE_SYS_MMAN_H) && defined(HAVE_MPROTECT)
230   uintptr_t pagesize = -1, mask, length;
231   const char *addr;
232
233 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
234   pagesize = (uintptr_t) sysconf (_SC_PAGE_SIZE);
235 #elif defined(HAVE_SYSCONF) && defined(_SC_PAGESIZE)
236   pagesize = (uintptr_t) sysconf (_SC_PAGESIZE);
237 #elif defined(HAVE_GETPAGESIZE)
238   pagesize = (uintptr_t) getpagesize ();
239 #endif
240
241   if ((uintptr_t) -1L == pagesize) {
242     (void) (HB_DEBUG_BLOB &&
243       fprintf (stderr, "%p %s: failed to get pagesize: %s\n", blob, __FUNCTION__, strerror (errno)));
244     return FALSE;
245   }
246   (void) (HB_DEBUG_BLOB &&
247     fprintf (stderr, "%p %s: pagesize is %lu\n", blob, __FUNCTION__, (unsigned long) pagesize));
248
249   mask = ~(pagesize-1);
250   addr = (const char *) (((uintptr_t) blob->data) & mask);
251   length = (const char *) (((uintptr_t) blob->data + blob->length + pagesize-1) & mask)  - addr;
252   (void) (HB_DEBUG_BLOB &&
253     fprintf (stderr, "%p %s: calling mprotect on [%p..%p] (%lu bytes)\n",
254              blob, __FUNCTION__,
255              addr, addr+length, (unsigned long) length));
256   if (-1 == mprotect ((void *) addr, length, PROT_READ | PROT_WRITE)) {
257     (void) (HB_DEBUG_BLOB &&
258       fprintf (stderr, "%p %s: %s\n", blob, __FUNCTION__, strerror (errno)));
259     return FALSE;
260   }
261
262   (void) (HB_DEBUG_BLOB &&
263     fprintf (stderr, "%p %s: successfully made [%p..%p] (%lu bytes) writable\n",
264              blob, __FUNCTION__,
265              addr, addr+length, (unsigned long) length));
266   return TRUE;
267 #else
268   return FALSE;
269 #endif
270 }
271
272 static void
273 try_writable_inplace_locked (hb_blob_t *blob)
274 {
275   (void) (HB_DEBUG_BLOB &&
276     fprintf (stderr, "%p %s: making writable\n", blob, __FUNCTION__));
277
278   if (_try_make_writable_inplace_unix_locked (blob)) {
279     (void) (HB_DEBUG_BLOB &&
280       fprintf (stderr, "%p %s: making writable -> succeeded\n", blob, __FUNCTION__));
281     blob->mode = HB_MEMORY_MODE_WRITABLE;
282   } else {
283     (void) (HB_DEBUG_BLOB &&
284       fprintf (stderr, "%p %s: making writable -> FAILED\n", blob, __FUNCTION__));
285     /* Failed to make writable inplace, mark that */
286     blob->mode = HB_MEMORY_MODE_READONLY;
287   }
288 }
289
290 hb_bool_t
291 hb_blob_try_writable_inplace (hb_blob_t *blob)
292 {
293   hb_memory_mode_t mode;
294
295   if (HB_OBJECT_IS_INERT (blob))
296     return FALSE;
297
298   hb_mutex_lock (blob->lock);
299
300   if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE)
301     try_writable_inplace_locked (blob);
302
303   mode = blob->mode;
304
305   hb_mutex_unlock (blob->lock);
306
307   return mode == HB_MEMORY_MODE_WRITABLE;
308 }
309
310 hb_bool_t
311 hb_blob_try_writable (hb_blob_t *blob)
312 {
313   hb_memory_mode_t mode;
314
315   if (HB_OBJECT_IS_INERT (blob))
316     return FALSE;
317
318   hb_mutex_lock (blob->lock);
319
320   if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE)
321     try_writable_inplace_locked (blob);
322
323   if (blob->mode == HB_MEMORY_MODE_READONLY)
324   {
325     char *new_data;
326
327     (void) (HB_DEBUG_BLOB &&
328       fprintf (stderr, "%p %s (%d) -> %p\n", blob, __FUNCTION__,
329                blob->lock_count, blob->data));
330
331     if (blob->lock_count)
332       goto done;
333
334     new_data = (char *) malloc (blob->length);
335     if (new_data) {
336       (void) (HB_DEBUG_BLOB &&
337         fprintf (stderr, "%p %s: dupped successfully -> %p\n", blob, __FUNCTION__, blob->data));
338       memcpy (new_data, blob->data, blob->length);
339       _hb_blob_destroy_user_data (blob);
340       blob->mode = HB_MEMORY_MODE_WRITABLE;
341       blob->data = new_data;
342       blob->user_data = new_data;
343       blob->destroy = free;
344     }
345   }
346
347 done:
348   mode = blob->mode;
349
350   hb_mutex_unlock (blob->lock);
351
352   return mode == HB_MEMORY_MODE_WRITABLE;
353 }
354
355
356 HB_END_DECLS