1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2 * Copyright by The HDF Group. *
3 * Copyright by the Board of Trustees of the University of Illinois. *
4 * All rights reserved. *
5 * *
6 * This file is part of HDF5. The full HDF5 copyright notice, including *
7 * terms governing use, modification, and redistribution, is contained in *
8 * the COPYING file, which can be found at the root of the source code *
9 * distribution tree, or in https://www.hdfgroup.org/licenses. *
10 * If you do not have access to either file, you may request a copy from *
11 * help@hdfgroup.org. *
12 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
13
14 /*-------------------------------------------------------------------------
15 *
16 * Created: H5Clog.c
17 *
18 * Purpose: Functions for metadata cache logging
19 *
20 *-------------------------------------------------------------------------
21 */
22
23 /****************/
24 /* Module Setup */
25 /****************/
26 #include "H5Cmodule.h" /* This source code file is part of the H5C module */
27
28 /***********/
29 /* Headers */
30 /***********/
31 #include "H5private.h" /* Generic Functions */
32 #define H5AC_FRIEND /* Suppress error about including H5ACpkg */
33 #include "H5ACpkg.h" /* Metadata cache */
34 #include "H5Cpkg.h" /* Cache */
35 #include "H5Clog.h" /* Cache logging */
36 #include "H5Eprivate.h" /* Error handling */
37
38 /****************/
39 /* Local Macros */
40 /****************/
41
42 /******************/
43 /* Local Typedefs */
44 /******************/
45
46 /********************/
47 /* Package Typedefs */
48 /********************/
49
50 /********************/
51 /* Local Prototypes */
52 /********************/
53
54 /*********************/
55 /* Package Variables */
56 /*********************/
57
58 /*****************************/
59 /* Library Private Variables */
60 /*****************************/
61
62 /*******************/
63 /* Local Variables */
64 /*******************/
65
66 /*-------------------------------------------------------------------------
67 * Function: H5C_log_set_up
68 *
69 * Purpose: Setup for metadata cache logging.
70 *
71 * Return: SUCCEED/FAIL
72 *
73 * Programmer: Dana Robinson
74 * Fall 2018
75 *
76 *-------------------------------------------------------------------------
77 */
78 herr_t
H5C_log_set_up(H5C_t * cache,const char log_location[],H5C_log_style_t style,hbool_t start_immediately)79 H5C_log_set_up(H5C_t *cache, const char log_location[], H5C_log_style_t style, hbool_t start_immediately)
80 {
81 int mpi_rank = -1; /* -1 indicates serial (no MPI rank) */
82 herr_t ret_value = SUCCEED; /* Return value */
83
84 FUNC_ENTER_NOAPI(FAIL)
85
86 /* Sanity checks */
87 HDassert(cache);
88 HDassert(log_location);
89
90 /* Check logging flags */
91 if (cache->log_info->enabled)
92 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "logging already set up")
93
94 /* Get the rank when MPI is in use. Logging clients will usually
95 * use that to create per-process logs.
96 */
97 #ifdef H5_HAVE_PARALLEL
98 if (NULL != cache->aux_ptr)
99 mpi_rank = ((H5AC_aux_t *)(cache->aux_ptr))->mpi_rank;
100 #endif /*H5_HAVE_PARALLEL*/
101
102 /* Set up logging */
103 if (H5C_LOG_STYLE_JSON == style) {
104 if (H5C_log_json_set_up(cache->log_info, log_location, mpi_rank) < 0)
105 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to set up json logging")
106 }
107 else if (H5C_LOG_STYLE_TRACE == style) {
108 if (H5C_log_trace_set_up(cache->log_info, log_location, mpi_rank) < 0)
109 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to set up trace logging")
110 }
111 else
112 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unknown logging style")
113
114 /* Set logging flags */
115 cache->log_info->enabled = TRUE;
116
117 /* Start logging if requested */
118 if (start_immediately)
119 if (H5C_start_logging(cache) < 0)
120 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to start logging")
121
122 done:
123
124 FUNC_LEAVE_NOAPI(ret_value)
125 } /* H5C_log_set_up() */
126
127 /*-------------------------------------------------------------------------
128 * Function: H5C_log_tear_down
129 *
130 * Purpose: Tear-down for metadata cache logging.
131 *
132 * Return: SUCCEED/FAIL
133 *
134 * Programmer: Dana Robinson
135 * Fall 2018
136 *
137 *-------------------------------------------------------------------------
138 */
139 herr_t
H5C_log_tear_down(H5C_t * cache)140 H5C_log_tear_down(H5C_t *cache)
141 {
142 herr_t ret_value = SUCCEED; /* Return value */
143
144 FUNC_ENTER_NOAPI(FAIL)
145
146 /* Sanity checks */
147 HDassert(cache);
148
149 /* Check logging flags */
150 if (FALSE == cache->log_info->enabled)
151 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "logging not enabled")
152
153 /* Stop logging if that's going on */
154 if (cache->log_info->logging)
155 if (H5C_stop_logging(cache) < 0)
156 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "unable to stop logging")
157
158 /* Tear down logging */
159 if (cache->log_info->cls->tear_down_logging)
160 if (cache->log_info->cls->tear_down_logging(cache->log_info) < 0)
161 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific tear down call failed")
162
163 /* Unset logging flags */
164 cache->log_info->enabled = FALSE;
165
166 done:
167 FUNC_LEAVE_NOAPI(ret_value)
168 } /* H5C_log_tear_down() */
169
170 /*-------------------------------------------------------------------------
171 * Function: H5C_start_logging
172 *
173 * Purpose: Start logging metadata cache operations.
174 *
175 * Return: SUCCEED/FAIL
176 *
177 * Programmer: Dana Robinson
178 * Fall 2018
179 *
180 *-------------------------------------------------------------------------
181 */
182 herr_t
H5C_start_logging(H5C_t * cache)183 H5C_start_logging(H5C_t *cache)
184 {
185 herr_t ret_value = SUCCEED; /* Return value */
186
187 FUNC_ENTER_NOAPI(FAIL)
188
189 /* Sanity checks */
190 HDassert(cache);
191
192 /* Check logging flags */
193 if (FALSE == cache->log_info->enabled)
194 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "logging not enabled")
195
196 /* Start logging */
197 if (cache->log_info->cls->start_logging)
198 if (cache->log_info->cls->start_logging(cache->log_info) < 0)
199 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific start call failed")
200
201 /* Set logging flags */
202 cache->log_info->logging = TRUE;
203
204 /* Write a log message */
205 if (cache->log_info->cls->write_start_log_msg)
206 if (cache->log_info->cls->write_start_log_msg(cache->log_info->udata) < 0)
207 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific write start call failed")
208
209 done:
210 FUNC_LEAVE_NOAPI(ret_value)
211 } /* H5C_start_logging() */
212
213 /*-------------------------------------------------------------------------
214 * Function: H5C_stop_logging
215 *
216 * Purpose: Stop logging metadata cache operations.
217 *
218 * Return: SUCCEED/FAIL
219 *
220 * Programmer: Dana Robinson
221 * Fall 2018
222 *
223 *-------------------------------------------------------------------------
224 */
225 herr_t
H5C_stop_logging(H5C_t * cache)226 H5C_stop_logging(H5C_t *cache)
227 {
228 herr_t ret_value = SUCCEED; /* Return value */
229
230 FUNC_ENTER_NOAPI(FAIL)
231
232 /* Sanity checks */
233 HDassert(cache);
234
235 /* Check logging flags */
236 if (FALSE == cache->log_info->enabled)
237 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "logging not enabled")
238 if (FALSE == cache->log_info->logging)
239 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "logging not in progress")
240
241 /* Write a log message */
242 if (cache->log_info->cls->write_stop_log_msg)
243 if (cache->log_info->cls->write_stop_log_msg(cache->log_info->udata) < 0)
244 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific write stop call failed")
245
246 /* Stop logging */
247 if (cache->log_info->cls->stop_logging)
248 if (cache->log_info->cls->stop_logging(cache->log_info) < 0)
249 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific stop call failed")
250
251 /* Set logging flags */
252 cache->log_info->logging = FALSE;
253
254 done:
255 FUNC_LEAVE_NOAPI(ret_value)
256 } /* H5C_stop_logging() */
257
258 /*-------------------------------------------------------------------------
259 * Function: H5C_get_logging_status
260 *
261 * Purpose: Determines if the cache is actively logging (via the OUT
262 * parameters).
263 *
264 * Return: SUCCEED/FAIL
265 *
266 * Programmer: Dana Robinson
267 * Fall 2018
268 *
269 *-------------------------------------------------------------------------
270 */
271 herr_t
H5C_get_logging_status(const H5C_t * cache,hbool_t * is_enabled,hbool_t * is_currently_logging)272 H5C_get_logging_status(const H5C_t *cache, hbool_t *is_enabled, hbool_t *is_currently_logging)
273 {
274 FUNC_ENTER_NOAPI_NOERR
275
276 /* Sanity checks */
277 HDassert(cache);
278 HDassert(is_enabled);
279 HDassert(is_currently_logging);
280
281 /* Get logging flags */
282 *is_enabled = cache->log_info->enabled;
283 *is_currently_logging = cache->log_info->logging;
284
285 FUNC_LEAVE_NOAPI(SUCCEED)
286 } /* H5C_get_logging_status() */
287
288 /*-------------------------------------------------------------------------
289 * Function: H5C_log_write_create_cache_msg
290 *
291 * Purpose: Write a log message for cache creation.
292 *
293 * Return: SUCCEED/FAIL
294 *
295 * Programmer: Dana Robinson
296 * Fall 2018
297 *
298 *-------------------------------------------------------------------------
299 */
300 herr_t
H5C_log_write_create_cache_msg(H5C_t * cache,herr_t fxn_ret_value)301 H5C_log_write_create_cache_msg(H5C_t *cache, herr_t fxn_ret_value)
302 {
303 herr_t ret_value = SUCCEED; /* Return value */
304
305 FUNC_ENTER_NOAPI(FAIL)
306
307 /* Sanity checks */
308 HDassert(cache);
309
310 /* Write a log message */
311 if (cache->log_info->cls->write_create_cache_log_msg)
312 if (cache->log_info->cls->write_create_cache_log_msg(cache->log_info->udata, fxn_ret_value) < 0)
313 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific write create cache call failed")
314
315 done:
316 FUNC_LEAVE_NOAPI(ret_value)
317 } /* H5C_log_write_create_cache_msg() */
318
319 /*-------------------------------------------------------------------------
320 * Function: H5C_log_write_destroy_cache_msg
321 *
322 * Purpose: Write a log message for cache destruction.
323 *
324 * NOTE: This can't print out the H5AC call return value, since we
325 * won't know that until the cache is destroyed and at that
326 * point we no longer have pointers to the logging information.
327 *
328 * Return: SUCCEED/FAIL
329 *
330 * Programmer: Dana Robinson
331 * Fall 2018
332 *
333 *-------------------------------------------------------------------------
334 */
335 herr_t
H5C_log_write_destroy_cache_msg(H5C_t * cache)336 H5C_log_write_destroy_cache_msg(H5C_t *cache)
337 {
338 herr_t ret_value = SUCCEED; /* Return value */
339
340 FUNC_ENTER_NOAPI(FAIL)
341
342 /* Sanity checks */
343 HDassert(cache);
344
345 /* Write a log message */
346 if (cache->log_info->cls->write_destroy_cache_log_msg)
347 if (cache->log_info->cls->write_destroy_cache_log_msg(cache->log_info->udata) < 0)
348 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific write destroy cache call failed")
349
350 done:
351 FUNC_LEAVE_NOAPI(ret_value)
352 } /* H5C_log_write_destroy_cache_msg() */
353
354 /*-------------------------------------------------------------------------
355 * Function: H5C_log_write_evict_cache_msg
356 *
357 * Purpose: Write a log message for eviction of cache entries.
358 *
359 * Return: SUCCEED/FAIL
360 *
361 * Programmer: Dana Robinson
362 * Fall 2018
363 *
364 *-------------------------------------------------------------------------
365 */
366 herr_t
H5C_log_write_evict_cache_msg(H5C_t * cache,herr_t fxn_ret_value)367 H5C_log_write_evict_cache_msg(H5C_t *cache, herr_t fxn_ret_value)
368 {
369 herr_t ret_value = SUCCEED;
370
371 FUNC_ENTER_NOAPI(FAIL)
372
373 /* Sanity checks */
374 HDassert(cache);
375
376 /* Write a log message */
377 if (cache->log_info->cls->write_evict_cache_log_msg)
378 if (cache->log_info->cls->write_evict_cache_log_msg(cache->log_info->udata, fxn_ret_value) < 0)
379 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific write evict cache call failed")
380
381 done:
382 FUNC_LEAVE_NOAPI(ret_value)
383 } /* H5C_log_write_evict_cache_msg() */
384
385 /*-------------------------------------------------------------------------
386 * Function: H5C_log_write_expunge_entry_msg
387 *
388 * Purpose: Write a log message for expunge of cache entries.
389 *
390 * Return: SUCCEED/FAIL
391 *
392 * Programmer: Dana Robinson
393 * Fall 2018
394 *
395 *-------------------------------------------------------------------------
396 */
397 herr_t
H5C_log_write_expunge_entry_msg(H5C_t * cache,haddr_t address,int type_id,herr_t fxn_ret_value)398 H5C_log_write_expunge_entry_msg(H5C_t *cache, haddr_t address, int type_id, herr_t fxn_ret_value)
399 {
400 herr_t ret_value = SUCCEED;
401
402 FUNC_ENTER_NOAPI(FAIL)
403
404 /* Sanity checks */
405 HDassert(cache);
406
407 /* Write a log message */
408 if (cache->log_info->cls->write_expunge_entry_log_msg)
409 if (cache->log_info->cls->write_expunge_entry_log_msg(cache->log_info->udata, address, type_id,
410 fxn_ret_value) < 0)
411 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific write expunge entry call failed")
412
413 done:
414 FUNC_LEAVE_NOAPI(ret_value)
415 } /* H5C_log_write_expunge_entry_msg() */
416
417 /*-------------------------------------------------------------------------
418 * Function: H5C_log_write_flush_cache_msg
419 *
420 * Purpose: Write a log message for cache flushes.
421 *
422 * Return: SUCCEED/FAIL
423 *
424 * Programmer: Dana Robinson
425 * Fall 2018
426 *
427 *-------------------------------------------------------------------------
428 */
429 herr_t
H5C_log_write_flush_cache_msg(H5C_t * cache,herr_t fxn_ret_value)430 H5C_log_write_flush_cache_msg(H5C_t *cache, herr_t fxn_ret_value)
431 {
432 herr_t ret_value = SUCCEED;
433
434 FUNC_ENTER_NOAPI(FAIL)
435
436 /* Sanity checks */
437 HDassert(cache);
438
439 /* Write a log message */
440 if (cache->log_info->cls->write_flush_cache_log_msg)
441 if (cache->log_info->cls->write_flush_cache_log_msg(cache->log_info->udata, fxn_ret_value) < 0)
442 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific flush cache call failed")
443
444 done:
445 FUNC_LEAVE_NOAPI(ret_value)
446 } /* H5C_log_write_flush_cache_msg() */
447
448 /*-------------------------------------------------------------------------
449 * Function: H5C_log_write_insert_entry_msg
450 *
451 * Purpose: Write a log message for insertion of cache entries.
452 *
453 * Return: SUCCEED/FAIL
454 *
455 * Programmer: Dana Robinson
456 * Fall 2018
457 *
458 *-------------------------------------------------------------------------
459 */
460 herr_t
H5C_log_write_insert_entry_msg(H5C_t * cache,haddr_t address,int type_id,unsigned flags,size_t size,herr_t fxn_ret_value)461 H5C_log_write_insert_entry_msg(H5C_t *cache, haddr_t address, int type_id, unsigned flags, size_t size,
462 herr_t fxn_ret_value)
463 {
464 herr_t ret_value = SUCCEED;
465
466 FUNC_ENTER_NOAPI(FAIL)
467
468 /* Sanity checks */
469 HDassert(cache);
470
471 /* Write a log message */
472 if (cache->log_info->cls->write_insert_entry_log_msg)
473 if (cache->log_info->cls->write_insert_entry_log_msg(cache->log_info->udata, address, type_id, flags,
474 size, fxn_ret_value) < 0)
475 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific insert entry call failed")
476
477 done:
478 FUNC_LEAVE_NOAPI(ret_value)
479 } /* H5C_log_write_insert_entry_msg() */
480
481 /*-------------------------------------------------------------------------
482 * Function: H5C_log_write_mark_entry_dirty_msg
483 *
484 * Purpose: Write a log message for marking cache entries as dirty.
485 *
486 * Return: SUCCEED/FAIL
487 *
488 * Programmer: Dana Robinson
489 * Fall 2018
490 *
491 *-------------------------------------------------------------------------
492 */
493 herr_t
H5C_log_write_mark_entry_dirty_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)494 H5C_log_write_mark_entry_dirty_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
495 {
496 herr_t ret_value = SUCCEED;
497
498 FUNC_ENTER_NOAPI(FAIL)
499
500 /* Sanity checks */
501 HDassert(cache);
502
503 /* Write a log message */
504 HDassert(entry);
505 if (cache->log_info->cls->write_mark_entry_dirty_log_msg)
506 if (cache->log_info->cls->write_mark_entry_dirty_log_msg(cache->log_info->udata, entry,
507 fxn_ret_value) < 0)
508 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific mark dirty entry call failed")
509
510 done:
511 FUNC_LEAVE_NOAPI(ret_value)
512 } /* H5C_log_write_mark_entry_dirty_msg() */
513
514 /*-------------------------------------------------------------------------
515 * Function: H5C_log_write_mark_entry_clean_msg
516 *
517 * Purpose: Write a log message for marking cache entries as clean.
518 *
519 * Return: SUCCEED/FAIL
520 *
521 * Programmer: Dana Robinson
522 * Fall 2018
523 *
524 *-------------------------------------------------------------------------
525 */
526 herr_t
H5C_log_write_mark_entry_clean_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)527 H5C_log_write_mark_entry_clean_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
528 {
529 herr_t ret_value = SUCCEED; /* Return value */
530
531 FUNC_ENTER_NOAPI(FAIL)
532
533 /* Sanity checks */
534 HDassert(cache);
535
536 /* Write a log message */
537 HDassert(entry);
538 if (cache->log_info->cls->write_mark_entry_clean_log_msg)
539 if (cache->log_info->cls->write_mark_entry_clean_log_msg(cache->log_info->udata, entry,
540 fxn_ret_value) < 0)
541 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific mark clean entry call failed")
542
543 done:
544 FUNC_LEAVE_NOAPI(ret_value)
545 } /* H5C_log_write_mark_entry_clean_msg() */
546
547 /*-------------------------------------------------------------------------
548 * Function: H5C_log_write_mark_unserialized_entry_msg
549 *
550 * Purpose: Write a log message for marking cache entries as unserialized.
551 *
552 * Return: SUCCEED/FAIL
553 *
554 * Programmer: Dana Robinson
555 * Fall 2018
556 *
557 *-------------------------------------------------------------------------
558 */
559 herr_t
H5C_log_write_mark_unserialized_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)560 H5C_log_write_mark_unserialized_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
561 {
562 herr_t ret_value = SUCCEED;
563
564 FUNC_ENTER_NOAPI(FAIL)
565
566 /* Sanity checks */
567 HDassert(cache);
568
569 /* Write a log message */
570 HDassert(entry);
571 if (cache->log_info->cls->write_mark_unserialized_entry_log_msg)
572 if (cache->log_info->cls->write_mark_unserialized_entry_log_msg(cache->log_info->udata, entry,
573 fxn_ret_value) < 0)
574 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific mark unserialized entry call failed")
575
576 done:
577 FUNC_LEAVE_NOAPI(ret_value)
578 } /* H5C_log_write_mark_unserialized_entry_msg() */
579
580 /*-------------------------------------------------------------------------
581 * Function: H5C_log_write_mark_serialized_entry_msg
582 *
583 * Purpose: Write a log message for marking cache entries as serialize.
584 *
585 * Return: SUCCEED/FAIL
586 *
587 * Programmer: Dana Robinson
588 * Fall 2018
589 *
590 *-------------------------------------------------------------------------
591 */
592 herr_t
H5C_log_write_mark_serialized_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)593 H5C_log_write_mark_serialized_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
594 {
595 herr_t ret_value = SUCCEED; /* Return value */
596
597 FUNC_ENTER_NOAPI(FAIL)
598
599 /* Sanity checks */
600 HDassert(cache);
601
602 /* Write a log message */
603 HDassert(entry);
604 if (cache->log_info->cls->write_mark_serialized_entry_log_msg)
605 if (cache->log_info->cls->write_mark_serialized_entry_log_msg(cache->log_info->udata, entry,
606 fxn_ret_value) < 0)
607 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific mark serialized entry call failed")
608
609 done:
610 FUNC_LEAVE_NOAPI(ret_value)
611 } /* H5C_log_write_mark_serialized_entry_msg() */
612
613 /*-------------------------------------------------------------------------
614 * Function: H5C_log_write_move_entry_msg
615 *
616 * Purpose: Write a log message for moving a cache entry.
617 *
618 * Return: SUCCEED/FAIL
619 *
620 * Programmer: Dana Robinson
621 * Fall 2018
622 *
623 *-------------------------------------------------------------------------
624 */
625 herr_t
H5C_log_write_move_entry_msg(H5C_t * cache,haddr_t old_addr,haddr_t new_addr,int type_id,herr_t fxn_ret_value)626 H5C_log_write_move_entry_msg(H5C_t *cache, haddr_t old_addr, haddr_t new_addr, int type_id,
627 herr_t fxn_ret_value)
628 {
629 herr_t ret_value = SUCCEED;
630
631 FUNC_ENTER_NOAPI(FAIL)
632
633 /* Sanity checks */
634 HDassert(cache);
635
636 /* Write a log message */
637 if (cache->log_info->cls->write_move_entry_log_msg)
638 if (cache->log_info->cls->write_move_entry_log_msg(cache->log_info->udata, old_addr, new_addr,
639 type_id, fxn_ret_value) < 0)
640 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific move entry call failed")
641
642 done:
643 FUNC_LEAVE_NOAPI(ret_value)
644 } /* H5C_log_write_move_entry_msg() */
645
646 /*-------------------------------------------------------------------------
647 * Function: H5C_log_write_pin_entry_msg
648 *
649 * Purpose: Write a log message for pinning a cache entry.
650 *
651 * Return: SUCCEED/FAIL
652 *
653 * Programmer: Dana Robinson
654 * Fall 2018
655 *
656 *-------------------------------------------------------------------------
657 */
658 herr_t
H5C_log_write_pin_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)659 H5C_log_write_pin_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
660 {
661 herr_t ret_value = SUCCEED;
662
663 FUNC_ENTER_NOAPI(FAIL)
664
665 /* Sanity checks */
666 HDassert(cache);
667
668 /* Write a log message */
669 HDassert(entry);
670 if (cache->log_info->cls->write_pin_entry_log_msg)
671 if (cache->log_info->cls->write_pin_entry_log_msg(cache->log_info->udata, entry, fxn_ret_value) < 0)
672 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific pin entry call failed")
673
674 done:
675 FUNC_LEAVE_NOAPI(ret_value)
676 } /* H5C_log_write_pin_entry_msg() */
677
678 /*-------------------------------------------------------------------------
679 * Function: H5C_log_write_create_fd_msg
680 *
681 * Purpose: Write a log message for creating a flush dependency between
682 * two cache entries.
683 *
684 * Return: SUCCEED/FAIL
685 *
686 * Programmer: Dana Robinson
687 * Fall 2018
688 *
689 *-------------------------------------------------------------------------
690 */
691 herr_t
H5C_log_write_create_fd_msg(H5C_t * cache,const H5C_cache_entry_t * parent,const H5C_cache_entry_t * child,herr_t fxn_ret_value)692 H5C_log_write_create_fd_msg(H5C_t *cache, const H5C_cache_entry_t *parent, const H5C_cache_entry_t *child,
693 herr_t fxn_ret_value)
694 {
695 herr_t ret_value = SUCCEED;
696
697 FUNC_ENTER_NOAPI(FAIL)
698
699 /* Sanity checks */
700 HDassert(cache);
701
702 /* Write a log message */
703 HDassert(parent);
704 HDassert(child);
705 if (cache->log_info->cls->write_create_fd_log_msg)
706 if (cache->log_info->cls->write_create_fd_log_msg(cache->log_info->udata, parent, child,
707 fxn_ret_value) < 0)
708 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific create fd call failed")
709
710 done:
711 FUNC_LEAVE_NOAPI(ret_value)
712 } /* H5C_log_write_create_fd_msg() */
713
714 /*-------------------------------------------------------------------------
715 * Function: H5C_log_write_protect_entry_msg
716 *
717 * Purpose: Write a log message for protecting a cache entry.
718 *
719 * Return: SUCCEED/FAIL
720 *
721 * Programmer: Dana Robinson
722 * Fall 2018
723 *
724 *-------------------------------------------------------------------------
725 */
726 herr_t
H5C_log_write_protect_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,int type_id,unsigned flags,herr_t fxn_ret_value)727 H5C_log_write_protect_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, int type_id, unsigned flags,
728 herr_t fxn_ret_value)
729 {
730 herr_t ret_value = SUCCEED;
731
732 FUNC_ENTER_NOAPI(FAIL)
733
734 /* Sanity checks */
735 HDassert(cache);
736
737 /* Write a log message */
738 HDassert(entry);
739 if (cache->log_info->cls->write_protect_entry_log_msg)
740 if (cache->log_info->cls->write_protect_entry_log_msg(cache->log_info->udata, entry, type_id, flags,
741 fxn_ret_value) < 0)
742 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific protect entry call failed")
743
744 done:
745 FUNC_LEAVE_NOAPI(ret_value)
746 } /* H5C_log_write_protect_entry_msg() */
747
748 /*-------------------------------------------------------------------------
749 * Function: H5C_log_write_resize_entry_msg
750 *
751 * Purpose: Write a log message for resizing a cache entry.
752 *
753 * Return: SUCCEED/FAIL
754 *
755 * Programmer: Dana Robinson
756 * Fall 2018
757 *
758 *-------------------------------------------------------------------------
759 */
760 herr_t
H5C_log_write_resize_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,size_t new_size,herr_t fxn_ret_value)761 H5C_log_write_resize_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, size_t new_size,
762 herr_t fxn_ret_value)
763 {
764 herr_t ret_value = SUCCEED;
765
766 FUNC_ENTER_NOAPI(FAIL)
767
768 /* Sanity checks */
769 HDassert(cache);
770
771 /* Write a log message */
772 HDassert(entry);
773 if (cache->log_info->cls->write_resize_entry_log_msg)
774 if (cache->log_info->cls->write_resize_entry_log_msg(cache->log_info->udata, entry, new_size,
775 fxn_ret_value) < 0)
776 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific resize entry call failed")
777
778 done:
779 FUNC_LEAVE_NOAPI(ret_value)
780 } /* H5C_log_write_resize_entry_msg() */
781
782 /*-------------------------------------------------------------------------
783 * Function: H5C_log_write_unpin_entry_msg
784 *
785 * Purpose: Write a log message for unpinning a cache entry.
786 *
787 * Return: SUCCEED/FAIL
788 *
789 * Programmer: Dana Robinson
790 * Fall 2018
791 *
792 *-------------------------------------------------------------------------
793 */
794 herr_t
H5C_log_write_unpin_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)795 H5C_log_write_unpin_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
796 {
797 herr_t ret_value = SUCCEED;
798
799 FUNC_ENTER_NOAPI(FAIL)
800
801 /* Sanity checks */
802 HDassert(cache);
803
804 /* Write a log message */
805 HDassert(entry);
806 if (cache->log_info->cls->write_unpin_entry_log_msg)
807 if (cache->log_info->cls->write_unpin_entry_log_msg(cache->log_info->udata, entry, fxn_ret_value) < 0)
808 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific unpin entry call failed")
809
810 done:
811 FUNC_LEAVE_NOAPI(ret_value)
812 } /* H5C_log_write_unpin_entry_msg() */
813
814 /*-------------------------------------------------------------------------
815 * Function: H5C_log_write_destroy_fd_msg
816 *
817 * Purpose: Write a log message for destroying a flush dependency
818 * between two cache entries.
819 *
820 * Return: SUCCEED/FAIL
821 *
822 * Programmer: Dana Robinson
823 * Fall 2018
824 *
825 *-------------------------------------------------------------------------
826 */
827 herr_t
H5C_log_write_destroy_fd_msg(H5C_t * cache,const H5C_cache_entry_t * parent,const H5C_cache_entry_t * child,herr_t fxn_ret_value)828 H5C_log_write_destroy_fd_msg(H5C_t *cache, const H5C_cache_entry_t *parent, const H5C_cache_entry_t *child,
829 herr_t fxn_ret_value)
830 {
831 herr_t ret_value = SUCCEED;
832
833 FUNC_ENTER_NOAPI(FAIL)
834
835 /* Sanity checks */
836 HDassert(cache);
837
838 /* Write a log message */
839 HDassert(parent);
840 HDassert(child);
841 if (cache->log_info->cls->write_destroy_fd_log_msg)
842 if (cache->log_info->cls->write_destroy_fd_log_msg(cache->log_info->udata, parent, child,
843 fxn_ret_value) < 0)
844 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific destroy fd call failed")
845
846 done:
847 FUNC_LEAVE_NOAPI(ret_value)
848 } /* H5C_log_write_destroy_fd_msg() */
849
850 /*-------------------------------------------------------------------------
851 * Function: H5C_log_write_unprotect_entry_msg
852 *
853 * Purpose: Write a log message for unprotecting a cache entry.
854 *
855 * Return: SUCCEED/FAIL
856 *
857 * Programmer: Dana Robinson
858 * Fall 2018
859 *
860 *-------------------------------------------------------------------------
861 */
862 herr_t
H5C_log_write_unprotect_entry_msg(H5C_t * cache,haddr_t address,int type_id,unsigned flags,herr_t fxn_ret_value)863 H5C_log_write_unprotect_entry_msg(H5C_t *cache, haddr_t address, int type_id, unsigned flags,
864 herr_t fxn_ret_value)
865 {
866 herr_t ret_value = SUCCEED;
867
868 FUNC_ENTER_NOAPI(FAIL)
869
870 /* Sanity checks */
871 HDassert(cache);
872
873 /* Write a log message */
874 if (cache->log_info->cls->write_unprotect_entry_log_msg)
875 if (cache->log_info->cls->write_unprotect_entry_log_msg(cache->log_info->udata, address, type_id,
876 flags, fxn_ret_value) < 0)
877 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific unprotect entry call failed")
878
879 done:
880 FUNC_LEAVE_NOAPI(ret_value)
881 } /* H5C_log_write_unprotect_entry_msg() */
882
883 /*-------------------------------------------------------------------------
884 * Function: H5C_log_write_set_cache_config_msg
885 *
886 * Purpose: Write a log message for setting the cache configuration.
887 *
888 * Return: SUCCEED/FAIL
889 *
890 * Programmer: Dana Robinson
891 * Fall 2018
892 *
893 *-------------------------------------------------------------------------
894 */
895 herr_t
H5C_log_write_set_cache_config_msg(H5C_t * cache,const H5AC_cache_config_t * config,herr_t fxn_ret_value)896 H5C_log_write_set_cache_config_msg(H5C_t *cache, const H5AC_cache_config_t *config, herr_t fxn_ret_value)
897 {
898 herr_t ret_value = SUCCEED;
899
900 FUNC_ENTER_NOAPI(FAIL)
901
902 /* Sanity checks */
903 HDassert(cache);
904
905 /* Write a log message */
906 HDassert(config);
907 if (cache->log_info->cls->write_set_cache_config_log_msg)
908 if (cache->log_info->cls->write_set_cache_config_log_msg(cache->log_info->udata, config,
909 fxn_ret_value) < 0)
910 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific set cache config call failed")
911
912 done:
913 FUNC_LEAVE_NOAPI(ret_value)
914 } /* H5C_log_write_set_cache_config_msg() */
915
916 /*-------------------------------------------------------------------------
917 * Function: H5C_log_write_remove_entry_msg
918 *
919 * Purpose: Write a log message for removing a cache entry.
920 *
921 * Return: SUCCEED/FAIL
922 *
923 * Programmer: Dana Robinson
924 * Fall 2018
925 *
926 *-------------------------------------------------------------------------
927 */
928 herr_t
H5C_log_write_remove_entry_msg(H5C_t * cache,const H5C_cache_entry_t * entry,herr_t fxn_ret_value)929 H5C_log_write_remove_entry_msg(H5C_t *cache, const H5C_cache_entry_t *entry, herr_t fxn_ret_value)
930 {
931 herr_t ret_value = SUCCEED;
932
933 FUNC_ENTER_NOAPI(FAIL)
934
935 /* Sanity checks */
936 HDassert(cache);
937
938 /* Write a log message */
939 HDassert(entry);
940 if (cache->log_info->cls->write_remove_entry_log_msg)
941 if (cache->log_info->cls->write_remove_entry_log_msg(cache->log_info->udata, entry, fxn_ret_value) <
942 0)
943 HGOTO_ERROR(H5E_CACHE, H5E_LOGGING, FAIL, "log-specific remove entry call failed")
944
945 done:
946 FUNC_LEAVE_NOAPI(ret_value)
947 } /* H5C_log_write_remove_entry_msg() */
948