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/qemu-progress.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 #ifdef SIGINFO 92 sigaction(SIGINFO, &action, NULL); 93 #endif 94 95 /* 96 * SIGUSR1 is SIG_IPI and gets blocked in qemu_init_main_loop(). In the 97 * tools that use the progress report SIGUSR1 isn't used in this meaning 98 * and instead should print the progress, so reenable it. 99 */ 100 sigemptyset(&set); 101 sigaddset(&set, SIGUSR1); 102 pthread_sigmask(SIG_UNBLOCK, &set, NULL); 103 #endif 104 105 state.print = progress_dummy_print; 106 state.end = progress_dummy_end; 107 } 108 109 /* 110 * Initialize progress reporting. 111 * If @enabled is false, actual reporting is suppressed. The user can 112 * still trigger a report by sending a SIGUSR1. 113 * Reports are also suppressed unless we've had at least @min_skip 114 * percent progress since the last report. 115 */ 116 void qemu_progress_init(int enabled, float min_skip) 117 { 118 state.min_skip = min_skip; 119 if (enabled) { 120 progress_simple_init(); 121 } else { 122 progress_dummy_init(); 123 } 124 } 125 126 void qemu_progress_end(void) 127 { 128 state.end(); 129 } 130 131 /* 132 * Report progress. 133 * @delta is how much progress we made. 134 * If @max is zero, @delta is an absolute value of the total job done. 135 * Else, @delta is a progress delta since the last call, as a fraction 136 * of @max. I.e. the delta is @delta * @max / 100. This allows 137 * relative accounting of functions which may be a different fraction of 138 * the full job, depending on the context they are called in. I.e. 139 * a function might be considered 40% of the full job if used from 140 * bdrv_img_create() but only 20% if called from img_convert(). 141 */ 142 void qemu_progress_print(float delta, int max) 143 { 144 float current; 145 146 if (max == 0) { 147 current = delta; 148 } else { 149 current = state.current + delta / 100 * max; 150 } 151 if (current > 100) { 152 current = 100; 153 } 154 state.current = current; 155 156 if (current > (state.last_print + state.min_skip) || 157 current < (state.last_print - state.min_skip) || 158 current == 100 || current == 0) { 159 state.last_print = state.current; 160 state.print(); 161 } 162 } 163