• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifdef LOG_TAG
18 #undef LOG_TAG
19 #endif
20 #define LOG_TAG "VSoCGrallocRegionRegistry"
21 
22 #include <limits.h>
23 #include <errno.h>
24 #include <pthread.h>
25 #include <unistd.h>
26 #include <string.h>
27 
28 #include <sys/mman.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 
32 #include <cutils/hashmap.h>
33 #include <cutils/log.h>
34 #include <cutils/atomic.h>
35 
36 #include <linux/ashmem.h>
37 
38 #include <hardware/hardware.h>
39 #include <hardware/gralloc.h>
40 #include <system/graphics.h>
41 
42 #include "gralloc_vsoc_priv.h"
43 
44 // TODO(ghartman): Make the configurable through a property
45 static const bool g_log_refs = false;
46 
47 struct GrallocRegion {
48   void* base_;
49   int   num_references_;
50 
51   GrallocRegion() : base_(0), num_references_(0) { }
52   // Copy constructors are ok.
53 };
54 
55 
56 static const char* get_buffer_name(
57     const private_handle_t* hnd, char output[ASHMEM_NAME_LEN]) {
58   output[0] = '\0';
59   if (!hnd) {
60     ALOGE("Attempted to log gralloc name hnd=NULL");
61     return output;
62   }
63   if (hnd->fd == -1) {
64     ALOGE("Attempted to log gralloc name hnd=%p with fd == -1", hnd);
65     return output;
66   }
67   int rval = ioctl(hnd->fd, ASHMEM_GET_NAME, output);
68   if (rval == -1) {
69     output[0] = '\0';
70   }
71   return output;
72 }
73 
74 
75 static int str_hash(void* str) {
76   return hashmapHash(str, strlen(reinterpret_cast<const char*>(str)));
77 }
78 
79 
80 static bool str_equal(void* a, void* b) {
81   return strcmp(
82       reinterpret_cast<const char*>(a),
83       reinterpret_cast<const char*>(b)) == 0;
84 }
85 
86 
87 static Hashmap* get_regions() {
88   static Hashmap* regionMap = hashmapCreate(19, str_hash, str_equal);
89   return regionMap;
90 }
91 
92 
93 static GrallocRegion* lock_region_for_handle(
94     const private_handle_t* hnd, char region_name[ASHMEM_NAME_LEN]) {
95   region_name[0] = '\0';
96   get_buffer_name(hnd, region_name);
97   Hashmap* hash = get_regions();
98   hashmapLock(hash);
99   GrallocRegion* region = reinterpret_cast<GrallocRegion*>(
100       hashmapGet(hash, region_name));
101   if (!region) {
102     region = new GrallocRegion;
103     hashmapPut(hash, strdup(region_name), region);
104   }
105   return region;
106 }
107 
108 
109 /* The current implementation uses only a single lock for all regions.
110  * This method takes a region to simplfy the refactoring if we go to
111  * finer-grained locks.
112  */
113 static inline void unlock_region(GrallocRegion* ) {
114   hashmapUnlock(get_regions());
115 }
116 
117 
118 void* reference_region(const char* op, const private_handle_t* hnd) {
119   char name_buf[ASHMEM_NAME_LEN];
120   GrallocRegion* region = lock_region_for_handle(hnd, name_buf);
121   if (!region->base_) {
122     void* mappedAddress = mmap(
123         0, hnd->total_size, PROT_READ|PROT_WRITE, MAP_SHARED, hnd->fd, 0);
124     if (mappedAddress == MAP_FAILED) {
125       ALOGE("Could not mmap %s", strerror(errno));
126       unlock_region(region);
127       return NULL;
128     }
129     // Set up the guard pages. The last page is always a guard
130     uintptr_t base = uintptr_t(mappedAddress);
131     uintptr_t addr = base + hnd->total_size - PAGE_SIZE;
132     if (mprotect((void*)addr, PAGE_SIZE, PROT_NONE) == -1) {
133       ALOGE("mprotect base=%p, pg=%p failed (%s)", (void*)base, (void*)addr,
134             strerror(errno));
135     }
136     region->base_ = mappedAddress;
137     ALOGI("Mapped %s hnd=%p fd=%d base=%p format=%s(0x%x) width=%d height=%d",
138           name_buf, hnd, hnd->fd, region->base_,
139           pixel_format_to_string(hnd->format), hnd->format,
140           hnd->x_res, hnd->y_res);
141   }
142 
143   void* rval = region->base_;
144   ++region->num_references_;
145   ALOGI_IF(g_log_refs, "Referencing name=%s op=%s addr=%p new numRefs=%d",
146         name_buf, op, region->base_, region->num_references_);
147   unlock_region(region);
148   return rval;
149 }
150 
151 
152 int unreference_region(const char* op, const private_handle_t* hnd) {
153   char name_buf[ASHMEM_NAME_LEN];
154 
155   GrallocRegion* region = lock_region_for_handle(hnd, name_buf);
156   if (!region->base_) {
157     ALOGE("Unmapping region with no map hnd=%p", hnd);
158     unlock_region(region);
159     return -1;
160   }
161   if (region->num_references_ < 1) {
162     ALOGE(
163         "unmap with hnd=%p, numReferences=%d", hnd, region->num_references_);
164     unlock_region(region);
165     return -1;
166   }
167   --region->num_references_;
168   if (!region->num_references_) {
169     ALOGI("Unmapped %s hnd=%p fd=%d base=%p", name_buf, hnd,
170           hnd->fd, region->base_);
171     if (munmap(region->base_, hnd->total_size) < 0) {
172       ALOGE("Could not unmap %s", strerror(errno));
173     }
174     region->base_ = 0;
175   }
176   ALOGI_IF(g_log_refs, "Unreferencing name=%s op=%s addr=%p new numRefs=%d",
177         name_buf, op, region->base_, region->num_references_);
178   unlock_region(region);
179   return 0;
180 }
181