Rev 3536 | Rev 4377 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 3536 | Rev 3597 | ||
---|---|---|---|
Line 46... | Line 46... | ||
46 | #include <ipc/ipc.h> |
46 | #include <ipc/ipc.h> |
47 | #include <as.h> |
47 | #include <as.h> |
48 | #include <assert.h> |
48 | #include <assert.h> |
49 | #include <futex.h> |
49 | #include <futex.h> |
50 | #include <libadt/list.h> |
50 | #include <libadt/list.h> |
- | 51 | #include <libadt/hash_table.h> |
|
51 | 52 | ||
52 | /** Lock protecting the device connection list */ |
53 | /** Lock protecting the device connection list */ |
53 | static futex_t dcl_lock = FUTEX_INITIALIZER; |
54 | static futex_t dcl_lock = FUTEX_INITIALIZER; |
54 | /** Device connection list head. */ |
55 | /** Device connection list head. */ |
55 | static LIST_INITIALIZE(dcl_head); |
56 | static LIST_INITIALIZE(dcl_head); |
56 | 57 | ||
- | 58 | #define CACHE_BUCKETS_LOG2 10 |
|
- | 59 | #define CACHE_BUCKETS (1 << CACHE_BUCKETS_LOG2) |
|
- | 60 | ||
- | 61 | typedef struct { |
|
- | 62 | futex_t lock; |
|
- | 63 | size_t block_size; /**< Block size. */ |
|
- | 64 | unsigned block_count; /**< Total number of blocks. */ |
|
- | 65 | hash_table_t block_hash; |
|
- | 66 | link_t free_head; |
|
- | 67 | } cache_t; |
|
- | 68 | ||
57 | typedef struct { |
69 | typedef struct { |
58 | link_t link; |
70 | link_t link; |
59 | int dev_handle; |
71 | int dev_handle; |
60 | int dev_phone; |
72 | int dev_phone; |
61 | void *com_area; |
73 | void *com_area; |
62 | size_t com_size; |
74 | size_t com_size; |
63 | void *bb_buf; |
75 | void *bb_buf; |
64 | off_t bb_off; |
76 | off_t bb_off; |
65 | size_t bb_size; |
77 | size_t bb_size; |
- | 78 | cache_t *cache; |
|
66 | } devcon_t; |
79 | } devcon_t; |
67 | 80 | ||
68 | static devcon_t *devcon_search(dev_handle_t dev_handle) |
81 | static devcon_t *devcon_search(dev_handle_t dev_handle) |
69 | { |
82 | { |
70 | link_t *cur; |
83 | link_t *cur; |
Line 80... | Line 93... | ||
80 | futex_up(&dcl_lock); |
93 | futex_up(&dcl_lock); |
81 | return NULL; |
94 | return NULL; |
82 | } |
95 | } |
83 | 96 | ||
84 | static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area, |
97 | static int devcon_add(dev_handle_t dev_handle, int dev_phone, void *com_area, |
85 | size_t com_size, void *bb_buf, off_t bb_off, size_t bb_size) |
98 | size_t com_size) |
86 | { |
99 | { |
87 | link_t *cur; |
100 | link_t *cur; |
88 | devcon_t *devcon; |
101 | devcon_t *devcon; |
89 | 102 | ||
90 | devcon = malloc(sizeof(devcon_t)); |
103 | devcon = malloc(sizeof(devcon_t)); |
Line 94... | Line 107... | ||
94 | link_initialize(&devcon->link); |
107 | link_initialize(&devcon->link); |
95 | devcon->dev_handle = dev_handle; |
108 | devcon->dev_handle = dev_handle; |
96 | devcon->dev_phone = dev_phone; |
109 | devcon->dev_phone = dev_phone; |
97 | devcon->com_area = com_area; |
110 | devcon->com_area = com_area; |
98 | devcon->com_size = com_size; |
111 | devcon->com_size = com_size; |
99 | devcon->bb_buf = bb_buf; |
112 | devcon->bb_buf = NULL; |
100 | devcon->bb_off = bb_off; |
113 | devcon->bb_off = 0; |
101 | devcon->bb_size = bb_size; |
114 | devcon->bb_size = 0; |
- | 115 | devcon->cache = NULL; |
|
102 | 116 | ||
103 | futex_down(&dcl_lock); |
117 | futex_down(&dcl_lock); |
104 | for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { |
118 | for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) { |
105 | devcon_t *d = list_get_instance(cur, devcon_t, link); |
119 | devcon_t *d = list_get_instance(cur, devcon_t, link); |
106 | if (d->dev_handle == dev_handle) { |
120 | if (d->dev_handle == dev_handle) { |
Line 119... | Line 133... | ||
119 | futex_down(&dcl_lock); |
133 | futex_down(&dcl_lock); |
120 | list_remove(&devcon->link); |
134 | list_remove(&devcon->link); |
121 | futex_up(&dcl_lock); |
135 | futex_up(&dcl_lock); |
122 | } |
136 | } |
123 | 137 | ||
124 | int |
- | |
125 | block_init(dev_handle_t dev_handle, size_t com_size, off_t bb_off, |
138 | int block_init(dev_handle_t dev_handle, size_t com_size) |
126 | size_t bb_size) |
- | |
127 | { |
139 | { |
128 | int rc; |
140 | int rc; |
129 | int dev_phone; |
141 | int dev_phone; |
130 | void *com_area; |
142 | void *com_area; |
131 | void *bb_buf; |
- | |
132 | - | ||
133 | bb_buf = malloc(bb_size); |
- | |
134 | if (!bb_buf) |
- | |
135 | return ENOMEM; |
- | |
136 | 143 | ||
137 | com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE, |
144 | com_area = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE, |
138 | MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); |
145 | MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); |
139 | if (!com_area) { |
146 | if (!com_area) { |
140 | free(bb_buf); |
- | |
141 | return ENOMEM; |
147 | return ENOMEM; |
142 | } |
148 | } |
143 | dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, |
149 | dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, |
144 | DEVMAP_CONNECT_TO_DEVICE, dev_handle); |
150 | DEVMAP_CONNECT_TO_DEVICE, dev_handle); |
145 | 151 | ||
146 | if (dev_phone < 0) { |
152 | if (dev_phone < 0) { |
147 | free(bb_buf); |
- | |
148 | munmap(com_area, com_size); |
153 | munmap(com_area, com_size); |
149 | return dev_phone; |
154 | return dev_phone; |
150 | } |
155 | } |
151 | 156 | ||
152 | rc = ipc_share_out_start(dev_phone, com_area, |
157 | rc = ipc_share_out_start(dev_phone, com_area, |
153 | AS_AREA_READ | AS_AREA_WRITE); |
158 | AS_AREA_READ | AS_AREA_WRITE); |
154 | if (rc != EOK) { |
159 | if (rc != EOK) { |
155 | free(bb_buf); |
- | |
156 | munmap(com_area, com_size); |
160 | munmap(com_area, com_size); |
157 | ipc_hangup(dev_phone); |
161 | ipc_hangup(dev_phone); |
158 | return rc; |
162 | return rc; |
159 | } |
163 | } |
160 | 164 | ||
161 | rc = devcon_add(dev_handle, dev_phone, com_area, com_size, bb_buf, |
165 | rc = devcon_add(dev_handle, dev_phone, com_area, com_size); |
162 | bb_off, bb_size); |
- | |
163 | if (rc != EOK) { |
166 | if (rc != EOK) { |
164 | free(bb_buf); |
- | |
165 | munmap(com_area, com_size); |
167 | munmap(com_area, com_size); |
166 | ipc_hangup(dev_phone); |
168 | ipc_hangup(dev_phone); |
167 | return rc; |
169 | return rc; |
168 | } |
170 | } |
169 | 171 | ||
170 | off_t bufpos = 0; |
- | |
171 | size_t buflen = 0; |
- | |
172 | if (!block_read(dev_handle, &bufpos, &buflen, &bb_off, |
- | |
173 | bb_buf, bb_size, bb_size)) { |
- | |
174 | block_fini(dev_handle); |
- | |
175 | return EIO; /* XXX real error code */ |
- | |
176 | } |
- | |
177 | - | ||
178 | return EOK; |
172 | return EOK; |
179 | } |
173 | } |
180 | 174 | ||
181 | void block_fini(dev_handle_t dev_handle) |
175 | void block_fini(dev_handle_t dev_handle) |
182 | { |
176 | { |
183 | devcon_t *devcon = devcon_search(dev_handle); |
177 | devcon_t *devcon = devcon_search(dev_handle); |
184 | assert(devcon); |
178 | assert(devcon); |
185 | 179 | ||
186 | devcon_remove(devcon); |
180 | devcon_remove(devcon); |
187 | 181 | ||
- | 182 | if (devcon->bb_buf) |
|
188 | free(devcon->bb_buf); |
183 | free(devcon->bb_buf); |
- | 184 | ||
- | 185 | if (devcon->cache) { |
|
- | 186 | hash_table_destroy(&devcon->cache->block_hash); |
|
- | 187 | free(devcon->cache); |
|
- | 188 | } |
|
- | 189 | ||
189 | munmap(devcon->com_area, devcon->com_size); |
190 | munmap(devcon->com_area, devcon->com_size); |
190 | ipc_hangup(devcon->dev_phone); |
191 | ipc_hangup(devcon->dev_phone); |
191 | 192 | ||
192 | free(devcon); |
193 | free(devcon); |
193 | } |
194 | } |
194 | 195 | ||
- | 196 | int block_bb_read(dev_handle_t dev_handle, off_t off, size_t size) |
|
- | 197 | { |
|
- | 198 | void *bb_buf; |
|
- | 199 | int rc; |
|
- | 200 | ||
- | 201 | devcon_t *devcon = devcon_search(dev_handle); |
|
- | 202 | if (!devcon) |
|
- | 203 | return ENOENT; |
|
- | 204 | if (devcon->bb_buf) |
|
- | 205 | return EEXIST; |
|
- | 206 | bb_buf = malloc(size); |
|
- | 207 | if (!bb_buf) |
|
- | 208 | return ENOMEM; |
|
- | 209 | ||
- | 210 | off_t bufpos = 0; |
|
- | 211 | size_t buflen = 0; |
|
- | 212 | rc = block_read(dev_handle, &bufpos, &buflen, &off, |
|
- | 213 | bb_buf, size, size); |
|
- | 214 | if (rc != EOK) { |
|
- | 215 | free(bb_buf); |
|
- | 216 | return rc; |
|
- | 217 | } |
|
- | 218 | devcon->bb_buf = bb_buf; |
|
- | 219 | devcon->bb_off = off; |
|
- | 220 | devcon->bb_size = size; |
|
- | 221 | ||
- | 222 | return EOK; |
|
- | 223 | } |
|
- | 224 | ||
195 | void *block_bb_get(dev_handle_t dev_handle) |
225 | void *block_bb_get(dev_handle_t dev_handle) |
196 | { |
226 | { |
197 | devcon_t *devcon = devcon_search(dev_handle); |
227 | devcon_t *devcon = devcon_search(dev_handle); |
198 | assert(devcon); |
228 | assert(devcon); |
199 | return devcon->bb_buf; |
229 | return devcon->bb_buf; |
200 | } |
230 | } |
201 | 231 | ||
- | 232 | static hash_index_t cache_hash(unsigned long *key) |
|
- | 233 | { |
|
- | 234 | return *key & (CACHE_BUCKETS - 1); |
|
- | 235 | } |
|
- | 236 | ||
- | 237 | static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item) |
|
- | 238 | { |
|
- | 239 | block_t *b = hash_table_get_instance(item, block_t, hash_link); |
|
- | 240 | return b->boff == *key; |
|
- | 241 | } |
|
- | 242 | ||
- | 243 | static void cache_remove_callback(link_t *item) |
|
- | 244 | { |
|
- | 245 | } |
|
- | 246 | ||
- | 247 | static hash_table_operations_t cache_ops = { |
|
- | 248 | .hash = cache_hash, |
|
- | 249 | .compare = cache_compare, |
|
- | 250 | .remove_callback = cache_remove_callback |
|
- | 251 | }; |
|
- | 252 | ||
- | 253 | int block_cache_init(dev_handle_t dev_handle, size_t size, unsigned blocks) |
|
- | 254 | { |
|
- | 255 | devcon_t *devcon = devcon_search(dev_handle); |
|
- | 256 | cache_t *cache; |
|
- | 257 | if (!devcon) |
|
- | 258 | return ENOENT; |
|
- | 259 | if (devcon->cache) |
|
- | 260 | return EEXIST; |
|
- | 261 | cache = malloc(sizeof(cache_t)); |
|
- | 262 | if (!cache) |
|
- | 263 | return ENOMEM; |
|
- | 264 | ||
- | 265 | futex_initialize(&cache->lock, 1); |
|
- | 266 | list_initialize(&cache->free_head); |
|
- | 267 | cache->block_size = size; |
|
- | 268 | cache->block_count = blocks; |
|
- | 269 | ||
- | 270 | if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 1, |
|
- | 271 | &cache_ops)) { |
|
- | 272 | free(cache); |
|
- | 273 | return ENOMEM; |
|
- | 274 | } |
|
- | 275 | ||
- | 276 | devcon->cache = cache; |
|
- | 277 | return EOK; |
|
- | 278 | } |
|
- | 279 | ||
- | 280 | static bool cache_can_grow(cache_t *cache) |
|
- | 281 | { |
|
- | 282 | return true; |
|
- | 283 | } |
|
- | 284 | ||
- | 285 | static void block_initialize(block_t *b) |
|
- | 286 | { |
|
- | 287 | futex_initialize(&b->lock, 1); |
|
- | 288 | b->refcnt = 1; |
|
- | 289 | b->dirty = false; |
|
- | 290 | rwlock_initialize(&b->contents_lock); |
|
- | 291 | link_initialize(&b->free_link); |
|
- | 292 | link_initialize(&b->hash_link); |
|
- | 293 | } |
|
- | 294 | ||
- | 295 | /** Instantiate a block in memory and get a reference to it. |
|
- | 296 | * |
|
- | 297 | * @param dev_handle Device handle of the block device. |
|
- | 298 | * @param boff Block offset. |
|
- | 299 | * @param flags If BLOCK_FLAGS_NOREAD is specified, block_get() |
|
- | 300 | * will not read the contents of the block from the |
|
- | 301 | * device. |
|
- | 302 | * |
|
- | 303 | * @return Block structure. |
|
- | 304 | */ |
|
- | 305 | block_t *block_get(dev_handle_t dev_handle, bn_t boff, int flags) |
|
- | 306 | { |
|
- | 307 | devcon_t *devcon; |
|
- | 308 | cache_t *cache; |
|
- | 309 | block_t *b; |
|
- | 310 | link_t *l; |
|
- | 311 | unsigned long key = boff; |
|
- | 312 | ||
- | 313 | devcon = devcon_search(dev_handle); |
|
- | 314 | ||
- | 315 | assert(devcon); |
|
- | 316 | assert(devcon->cache); |
|
- | 317 | ||
- | 318 | cache = devcon->cache; |
|
- | 319 | futex_down(&cache->lock); |
|
- | 320 | l = hash_table_find(&cache->block_hash, &key); |
|
- | 321 | if (l) { |
|
- | 322 | /* |
|
- | 323 | * We found the block in the cache. |
|
- | 324 | */ |
|
- | 325 | b = hash_table_get_instance(l, block_t, hash_link); |
|
- | 326 | futex_down(&b->lock); |
|
- | 327 | if (b->refcnt++ == 0) |
|
- | 328 | list_remove(&b->free_link); |
|
- | 329 | futex_up(&b->lock); |
|
- | 330 | futex_up(&cache->lock); |
|
- | 331 | } else { |
|
- | 332 | /* |
|
- | 333 | * The block was not found in the cache. |
|
- | 334 | */ |
|
- | 335 | int rc; |
|
- | 336 | off_t bufpos = 0; |
|
- | 337 | size_t buflen = 0; |
|
- | 338 | off_t pos = boff * cache->block_size; |
|
- | 339 | bool sync = false; |
|
- | 340 | ||
- | 341 | if (cache_can_grow(cache)) { |
|
- | 342 | /* |
|
- | 343 | * We can grow the cache by allocating new blocks. |
|
- | 344 | * Should the allocation fail, we fail over and try to |
|
- | 345 | * recycle a block from the cache. |
|
- | 346 | */ |
|
- | 347 | b = malloc(sizeof(block_t)); |
|
- | 348 | if (!b) |
|
- | 349 | goto recycle; |
|
- | 350 | b->data = malloc(cache->block_size); |
|
- | 351 | if (!b->data) { |
|
- | 352 | free(b); |
|
- | 353 | goto recycle; |
|
- | 354 | } |
|
- | 355 | } else { |
|
- | 356 | /* |
|
- | 357 | * Try to recycle a block from the free list. |
|
- | 358 | */ |
|
- | 359 | unsigned long temp_key; |
|
- | 360 | recycle: |
|
- | 361 | assert(!list_empty(&cache->free_head)); |
|
- | 362 | l = cache->free_head.next; |
|
- | 363 | list_remove(l); |
|
- | 364 | b = hash_table_get_instance(l, block_t, hash_link); |
|
- | 365 | sync = b->dirty; |
|
- | 366 | temp_key = b->boff; |
|
- | 367 | hash_table_remove(&cache->block_hash, &temp_key, 1); |
|
- | 368 | } |
|
- | 369 | ||
- | 370 | block_initialize(b); |
|
- | 371 | b->dev_handle = dev_handle; |
|
- | 372 | b->size = cache->block_size; |
|
- | 373 | b->boff = boff; |
|
- | 374 | hash_table_insert(&cache->block_hash, &key, &b->hash_link); |
|
- | 375 | ||
- | 376 | /* |
|
- | 377 | * Lock the block before releasing the cache lock. Thus we don't |
|
- | 378 | * kill concurent operations on the cache while doing I/O on the |
|
- | 379 | * block. |
|
- | 380 | */ |
|
- | 381 | futex_down(&b->lock); |
|
- | 382 | futex_up(&cache->lock); |
|
- | 383 | ||
- | 384 | if (sync) { |
|
- | 385 | /* |
|
- | 386 | * The block is dirty and needs to be written back to |
|
- | 387 | * the device before we can read in the new contents. |
|
- | 388 | */ |
|
- | 389 | abort(); /* TODO: block_write() */ |
|
- | 390 | } |
|
- | 391 | if (!(flags & BLOCK_FLAGS_NOREAD)) { |
|
- | 392 | /* |
|
- | 393 | * The block contains old or no data. We need to read |
|
- | 394 | * the new contents from the device. |
|
- | 395 | */ |
|
- | 396 | rc = block_read(dev_handle, &bufpos, &buflen, &pos, |
|
- | 397 | b->data, cache->block_size, cache->block_size); |
|
- | 398 | assert(rc == EOK); |
|
- | 399 | } |
|
- | 400 | ||
- | 401 | futex_up(&b->lock); |
|
- | 402 | } |
|
- | 403 | return b; |
|
- | 404 | } |
|
- | 405 | ||
- | 406 | /** Release a reference to a block. |
|
- | 407 | * |
|
- | 408 | * If the last reference is dropped, the block is put on the free list. |
|
- | 409 | * |
|
- | 410 | * @param block Block of which a reference is to be released. |
|
- | 411 | */ |
|
- | 412 | void block_put(block_t *block) |
|
- | 413 | { |
|
- | 414 | devcon_t *devcon = devcon_search(block->dev_handle); |
|
- | 415 | cache_t *cache; |
|
- | 416 | ||
- | 417 | assert(devcon); |
|
- | 418 | assert(devcon->cache); |
|
- | 419 | ||
- | 420 | cache = devcon->cache; |
|
- | 421 | futex_down(&cache->lock); |
|
- | 422 | futex_down(&block->lock); |
|
- | 423 | if (!--block->refcnt) { |
|
- | 424 | /* |
|
- | 425 | * Last reference to the block was dropped, put the block on the |
|
- | 426 | * free list. |
|
- | 427 | */ |
|
- | 428 | list_append(&block->free_link, &cache->free_head); |
|
- | 429 | } |
|
- | 430 | futex_up(&block->lock); |
|
- | 431 | futex_up(&cache->lock); |
|
- | 432 | } |
|
- | 433 | ||
202 | /** Read data from a block device. |
434 | /** Read data from a block device. |
203 | * |
435 | * |
204 | * @param dev_handle Device handle of the block device. |
436 | * @param dev_handle Device handle of the block device. |
205 | * @param bufpos Pointer to the first unread valid offset within the |
437 | * @param bufpos Pointer to the first unread valid offset within the |
206 | * communication buffer. |
438 | * communication buffer. |
Line 209... | Line 441... | ||
209 | * @param pos Device position to be read. |
441 | * @param pos Device position to be read. |
210 | * @param dst Destination buffer. |
442 | * @param dst Destination buffer. |
211 | * @param size Size of the destination buffer. |
443 | * @param size Size of the destination buffer. |
212 | * @param block_size Block size to be used for the transfer. |
444 | * @param block_size Block size to be used for the transfer. |
213 | * |
445 | * |
214 | * @return True on success, false on failure. |
446 | * @return EOK on success or a negative return code on failure. |
215 | */ |
447 | */ |
216 | bool |
448 | int |
217 | block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst, |
449 | block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst, |
218 | size_t size, size_t block_size) |
450 | size_t size, size_t block_size) |
219 | { |
451 | { |
220 | off_t offset = 0; |
452 | off_t offset = 0; |
221 | size_t left = size; |
453 | size_t left = size; |
Line 246... | Line 478... | ||
246 | /* Refill the communication buffer with a new block. */ |
478 | /* Refill the communication buffer with a new block. */ |
247 | ipcarg_t retval; |
479 | ipcarg_t retval; |
248 | int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK, |
480 | int rc = async_req_2_1(devcon->dev_phone, RD_READ_BLOCK, |
249 | *pos / block_size, block_size, &retval); |
481 | *pos / block_size, block_size, &retval); |
250 | if ((rc != EOK) || (retval != EOK)) |
482 | if ((rc != EOK) || (retval != EOK)) |
251 | return false; |
483 | return (rc != EOK ? rc : retval); |
252 | 484 | ||
253 | *bufpos = 0; |
485 | *bufpos = 0; |
254 | *buflen = block_size; |
486 | *buflen = block_size; |
255 | } |
487 | } |
256 | } |
488 | } |
257 | 489 | ||
258 | return true; |
- | |
259 | } |
- | |
260 | - | ||
261 | block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs) |
- | |
262 | { |
- | |
263 | /* FIXME */ |
- | |
264 | block_t *b; |
- | |
265 | off_t bufpos = 0; |
- | |
266 | size_t buflen = 0; |
- | |
267 | off_t pos = offset * bs; |
- | |
268 | - | ||
269 | b = malloc(sizeof(block_t)); |
- | |
270 | if (!b) |
- | |
271 | return NULL; |
- | |
272 | - | ||
273 | b->data = malloc(bs); |
- | |
274 | if (!b->data) { |
- | |
275 | free(b); |
- | |
276 | return NULL; |
- | |
277 | } |
- | |
278 | b->size = bs; |
- | |
279 | - | ||
280 | if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data, |
- | |
281 | bs, bs)) { |
- | |
282 | free(b->data); |
- | |
283 | free(b); |
- | |
284 | return NULL; |
- | |
285 | } |
- | |
286 | - | ||
287 | return b; |
490 | return EOK; |
288 | } |
- | |
289 | - | ||
290 | void block_put(block_t *block) |
- | |
291 | { |
- | |
292 | /* FIXME */ |
- | |
293 | free(block->data); |
- | |
294 | free(block); |
- | |
295 | } |
491 | } |
296 | 492 | ||
297 | /** @} |
493 | /** @} |
298 | */ |
494 | */ |