1 /* 2 * QEMU progress printing utility functions 3 * 4 * Copyright (C) 2011 Jes Sorensen <Jes.Sorensen@redhat.com> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 25 #include "qemu/osdep.h" 26 #include "qemu-common.h" 27 28 struct progress_state { 29 float current; 30 float last_print; 31 float min_skip; 32 void (*print)(void); 33 void (*end)(void); 34 }; 35 36 static struct progress_state state; 37 static volatile sig_atomic_t print_pending; 38 39 /* 40 * Simple progress print function. 41 * @percent relative percent of current operation 42 * @max percent of total operation 43 */ 44 static void progress_simple_print(void) 45 { 46 printf(" (%3.2f/100%%)\r", state.current); 47 fflush(stdout); 48 } 49 50 static void progress_simple_end(void) 51 { 52 printf("\n"); 53 } 54 55 static void progress_simple_init(void) 56 { 57 state.print = progress_simple_print; 58 state.end = progress_simple_end; 59 } 60 61 #ifdef CONFIG_POSIX 62 static void sigusr_print(int signal) 63 { 64 print_pending = 1; 65 } 66 #endif 67 68 static void progress_dummy_print(void) 69 { 70 if (print_pending) { 71 fprintf(stderr, " (%3.2f/100%%)\n", state.current); 72 print_pending = 0; 73 } 74 } 75 76 static void progress_dummy_end(void) 77 { 78 } 79 80 static void progress_dummy_init(void) 81 { 82 #ifdef CONFIG_POSIX 83 struct sigaction action; 84 sigset_t set; 85 86 memset(&action, 0, sizeof(action)); 87 sigfillset(&action.sa_mask); 88 action.sa_handler = sigusr_print; 89 action.sa_flags = 0; 90 sigaction(SIGUSR1, &action, NULL); 91 92 /* 93 * SIGUSR1 is SIG_IPI and gets blocked in qemu_init_main_loop(). In the 94 * tools that use the progress report SIGUSR1 isn't used in this meaning 95 * and instead should print the progress, so reenable it. 96 */ 97 sigemptyset(&set); 98 sigaddset(&set, SIGUSR1); 99 pthread_sigmask(SIG_UNBLOCK, &set, NULL); 100 #endif 101 102 state.print = progress_dummy_print; 103 state.end = progress_dummy_end; 104 } 105 106 /* 107 * Initialize progress reporting. 108 * If @enabled is false, actual reporting is suppressed. The user can 109 * still trigger a report by sending a SIGUSR1. 110 * Reports are also suppressed unless we've had at least @min_skip 111 * percent progress since the last report. 112 */ 113 void qemu_progress_init(int enabled, float min_skip) 114 { 115 state.min_skip = min_skip; 116 if (enabled) { 117 progress_simple_init(); 118 } else { 119 progress_dummy_init(); 120 } 121 } 122 123 void qemu_progress_end(void) 124 { 125 state.end(); 126 } 127 128 /* 129 * Report progress. 130 * @delta is how much progress we made. 131 * If @max is zero, @delta is an absolut value of the total job done. 132 * Else, @delta is a progress delta since the last call, as a fraction 133 * of @max. I.e. the delta is @delta * @max / 100. This allows 134 * relative accounting of functions which may be a different fraction of 135 * the full job, depending on the context they are called in. I.e. 136 * a function might be considered 40% of the full job if used from 137 * bdrv_img_create() but only 20% if called from img_convert(). 138 */ 139 void qemu_progress_print(float delta, int max) 140 { 141 float current; 142 143 if (max == 0) { 144 current = delta; 145 } else { 146 current = state.current + delta / 100 * max; 147 } 148 if (current > 100) { 149 current = 100; 150 } 151 state.current = current; 152 153 if (current > (state.last_print + state.min_skip) || 154 current < (state.last_print - state.min_skip) || 155 current == 100 || current == 0) { 156 state.last_print = state.current; 157 state.print(); 158 } 159 } 160