/** Reads the specified setup file, building a list of strings containing the operations to simulate.<br> Assumes that the file has a correct structure. @param pathname The setup file's path @return The list of operations to compute */ static list* parse_file(const char *const pathname) { list *result = list_construct(); char line[50]; int len, fd; if(result == NULL) exit(1); fd = open(pathname, O_RDONLY); if(fd == -1) { write_to_fd(2, "Failed to open setup file\n"); exit(1); } do { len = read_line(fd, line, 50); if (len > 0) list_append(result, line); } while(len >= 0); if (close(fd) == -1) { write_to_fd(2, "Failed to close setup file\n"); exit(1); } return result; }
void *fun2(void *ptr) { int fd = *((int *)ptr); /* No work needs to be done, send right away. */ write_to_fd(fd, "Hello"); sleep(3); /* Simulate work being done... */ write_to_fd(fd, "from "); close(fd); return NULL; }
void *fun1(void *ptr) { int fd = *((int *)ptr); sleep(2); /* Simulate work being done... */ write_to_fd(fd, "World"); sleep(3); /* Simulate work being done... */ write_to_fd(fd, "CS241"); close(fd); return NULL; }
/* Copy file of given length to output, and fail if the file has * changed size. */ static void write_file_len_to_fd (const char *filename, size_t len) { char buffer[BUFFER_SIZE]; size_t count = 0; if (verbose >= 2) fprintf (stderr, "write_file_to_fd %s -> %d\n", filename, out_fd); int fd2 = open (filename, O_RDONLY); if (fd2 == -1) error (EXIT_FAILURE, errno, "open: %s", filename); for (;;) { ssize_t r = read (fd2, buffer, sizeof buffer); if (r == 0) break; if (r == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) continue; error (EXIT_FAILURE, errno, "read: %s", filename); } write_to_fd (buffer, r); count += r; if (count > len) error (EXIT_FAILURE, 0, "write_file_len_to_fd: %s: file has increased in size\n", filename); } if (close (fd2) == -1) error (EXIT_FAILURE, errno, "close: %s", filename); if (count != len) error (EXIT_FAILURE, 0, "febootstrap-supermin-helper: write_file_len_to_fd: %s: file has changed size\n", filename); }
/* Copy contents of file to out_fd. */ static void write_file_to_fd (const char *filename) { char buffer[BUFFER_SIZE]; int fd2; ssize_t r; if (verbose >= 2) fprintf (stderr, "write_file_to_fd %s -> %d\n", filename, out_fd); fd2 = open (filename, O_RDONLY); if (fd2 == -1) error (EXIT_FAILURE, errno, "open: %s", filename); for (;;) { r = read (fd2, buffer, sizeof buffer); if (r == 0) break; if (r == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) continue; error (EXIT_FAILURE, errno, "read: %s", filename); } write_to_fd (buffer, r); } if (close (fd2) == -1) error (EXIT_FAILURE, errno, "close: %s", filename); }
/* Sets errno on error (!= 0), ENOSPC on short write */ int copy_file_data (int sfd, int dfd) { char buffer[BUFSIZE]; ssize_t bytes_read; while (TRUE) { bytes_read = read (sfd, buffer, BUFSIZE); if (bytes_read == -1) { if (errno == EINTR) continue; return -1; } if (bytes_read == 0) break; if (write_to_fd (dfd, buffer, bytes_read) != 0) return -1; } return 0; }
/** Searches the processor state array for a free processor (state <= 0). @param states The array of processor states. Each cell <i>i</i> contains a key such that:<br> <ul><li>If <b>key < 0</b>, processor has completed the |key|-th operation <li>If <b>key == 0</b>, processor has not received an operation yet <li>If <b>key > 0</b>, processor is currently working on the key-th operation</ul> @return The ID of a free processor */ static int find_proc(int *states) { int i = 0; sem_p(2 * processors); write_to_fd(1, "Looking for a free processor\n"); while(states[i++] > 0); sem_v(2 * processors); write_with_int(1, "Found processor ", i); return i - 1; }
/* Write 'len' bytes of zeroes out. */ static void write_padding (size_t len) { static const char buffer[512] = { 0 }; while (len > 0) { size_t n = len < sizeof buffer ? len : sizeof buffer; write_to_fd (buffer, n); len -= n; } }
static gboolean dump_container_properties(gs_container_t * container) { GSList *properties = NULL, *list = NULL; struct metacnx_ctx_s cnx; gchar path[1024]; int output_fd; GError *error = NULL; metacnx_clear(&cnx); if (!metacnx_init_with_addr(&cnx, &(container->meta2_addr), &error)) { PRINT_ERROR("Invalid META2 address : %s", error->message); g_clear_error(&error); return FALSE; } /* Change default timeout */ cnx.timeout.req = 10000; cnx.timeout.cnx = 10000; if (!meta2_remote_list_all_container_properties(&cnx, container->cID, &properties, &error)) { PRINT_ERROR("Failed to list container properties : %s", error->message); g_clear_error(&error); return FALSE; } metacnx_close(&cnx); metacnx_clear(&cnx); /* open container properties file */ memset(path, '\0', sizeof(path)); g_snprintf(path, sizeof(path), "%s/container.properties", base_dir); output_fd = open(path, O_EXCL | O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); if (output_fd < 0) { PRINT_ERROR("Failed to open [%s] as the container properties target : %s\n", path, strerror(errno)); return FALSE; } /* Print container properties to file */ if (g_slist_length(properties)>0) { for (list = properties; list && list->data; list = list->next) { gchar *txt = g_strdup_printf("%s\n", (char*)list->data); write_to_fd(&output_fd, txt, strlen(txt)); g_free(txt); } } /*then adjust the file rights */ fchmod(output_fd, S_IRGRP | S_IRUSR | S_IWUSR); close(output_fd); g_slist_foreach(properties, gslist_free_element, g_free); g_slist_free(properties); return TRUE; }
/** Forks and executes the required number of processors. */ static void start_processors(void) { int i, pid; char proc_id[8], nsems[8]; if(itoa((2 * processors) + 2, nsems, 8) == -1) { write_to_fd(2, "Failed to convert number of semaphores\n"); kill_group(SIGTERM); } for (i = 0; i < processors; ++i) { pid = fork(); if (pid == -1) { write_to_fd(2, "Failed to fork processor\n"); kill_group(SIGTERM); } if (pid == 0) { if(itoa(i, proc_id, 8) != -1) execl("processor.x", "processor.x", proc_id, nsems, (char *) NULL); kill_group(SIGTERM); } } }
/* Sets errno on error (!= 0), ENOSPC on short write */ int create_file (const char *path, mode_t mode, const char *content) { int fd; int res; int errsv; fd = creat (path, mode); if (fd == -1) return -1; res = 0; if (content) res = write_to_fd (fd, content, strlen (content)); errsv = errno; close (fd); errno = errsv; return res; }
/* Sets errno on error (!= 0), ENOSPC on short write */ int write_file_at (int dirfd, const char *path, const char *content) { int fd; bool res; int errsv; fd = openat (dirfd, path, O_RDWR | O_CLOEXEC, 0); if (fd == -1) return -1; res = 0; if (content) res = write_to_fd (fd, content, strlen (content)); errsv = errno; close (fd); errno = errsv; return res; }
/** Carries out simulation setup and management. @param argc The number of arguments @param argv The array of arguments */ int main(int argc, char *argv[]) { int *results, *shm_states; int i, op_count, proc_id; char *tmp_operator, *cmd; list *commands; operation *shm_operations; if(signal(SIGTERM, &stop_execution) == SIG_ERR) { write_to_fd(2, "Failed to register signal\n"); exit(1); } if(argc != 3) { write_to_fd(2, "Usage: main.x <source file> <results file>\n"); exit(1); } commands = parse_file(argv[1]); processors = atoi(list_extract(commands)); if (processors <= 0) { write_to_fd(2, "Invalid number of processors\n"); exit(1); } write_with_int(1, "Number of processors: ", processors); op_count = list_count(commands); if (op_count == 0) { write_to_fd(2, "No operations provided\n"); exit(1); } write_with_int(1, "Number of operations: ", op_count); results = (int *) malloc(op_count * sizeof(int)); if (results == NULL) { write_to_fd(2, "Failed to allocate results array\n"); exit(1); } init_ipc(2 * processors + 2, processors * sizeof(operation), processors * sizeof(int), 0666 | IPC_CREAT | IPC_EXCL); write_with_int(1, "Created semaphore set with ID ", ipc_id[0]); write_with_int(1, "Created shm for operations with ID ", ipc_id[1]); write_with_int(1, "Created shm for states with ID ", ipc_id[2]); init_sems(processors); shm_operations = (operation *) shm_attach(ipc_id[1]); shm_states = (int *) shm_attach(ipc_id[2]); for (i = 0; i < processors; ++i) shm_states[i] = 0; start_processors(); for (i = 1; list_count(commands) > 0; ++i) { cmd = list_extract(commands); write_with_int(1, "\nOperation #", i); proc_id = atoi(strtok(cmd, " ")); sem_p(2 * processors + 1); if (proc_id-- == 0) { proc_id = find_proc(shm_states); } write_with_int(1, "Waiting for processor ", proc_id + 1); sem_p(2 * proc_id); write_with_int(1, "Delivering operation to processor ", proc_id + 1); if (shm_states[proc_id] != 0) { results[(shm_states[proc_id] + 1) * -1] = shm_operations[proc_id].num1; write_with_int(1, "Previous result: ", shm_operations[proc_id].num1); } shm_operations[proc_id].num1 = atoi(strtok(NULL, " ")); tmp_operator = strtok(NULL, " "); shm_operations[proc_id].op = *tmp_operator; shm_operations[proc_id].num2 = atoi(strtok(NULL, " ")); shm_states[proc_id] = i; write_with_int(1, "Operation delivered. Unblocking processor ", proc_id + 1); sem_v((2 * proc_id) + 1); free(cmd); } list_destruct(commands); for (i = 0; i < processors; ++i) { sem_p(2 * i); write_with_int(1, "\nPassing termination command to processor #", i + 1); if (shm_states[i] != 0) { results[(shm_states[i] + 1) * -1] = shm_operations[i].num1; write_with_int(1, "Last result: ", shm_operations[i].num1); } shm_operations[i].op = 'K'; sem_v((2 * i) + 1); } for (i = 0; i < processors; ++i) if(wait(NULL) == -1) write_to_fd(2, "Wait failed\n"); write_to_fd(1, "\nAll processors exited. Writing output file\n"); write_results(argv[2], results, op_count); free(results); write_to_fd(1, "Closing IPCs\n"); shm_detach((void *) shm_operations); shm_detach((void *) shm_states); close_ipc(); exit(0); }
/** Handles the @c SIGTERM signal by closing all IPCs. @param signum The received signal */ static void stop_execution(int signum) { write_to_fd(2, "SIGTERM received. Closing IPCs\n"); close_ipc(); exit(1); }
int suspend_test(void) { char wakelock_dmask[16] = ""; char earlysuspend_dmask[16] = ""; time_t now; time_t expiration; int success_count = 0; int rv; int i = 0; int k; int num_success = 0; int ret; unsigned int core1_status; unsigned int core2_status; unsigned int core3_status; unsigned int dual_core = 0; signed long usb_active; int num_cores = 0; char *ss_pid; fprintf(stdout, "Determine if wakelock node is there \n"); g_wakelock_exists = file_exists(WAKELOCK_NODE); if (g_wakelock_exists) { fprintf(stdout, "reset the sensors data setting \n"); rv = write_string_to_file(NULL, SENSOR_SETTINGS, "0\n"); if (rv < 0) { fprintf(stdout, "unable to set sensor settings: %s\n", strerror(-rv)); goto suspend_test_early_bailout; } fprintf(stdout, "sleep for sensor daemon to pick up the setting \n"); sleep(2); fprintf(stdout, "Save current wakelock debug mask\n"); rv = read_from_file( NULL, WAKELOCK_DEBUG_MASK_NODE, wakelock_dmask, sizeof(wakelock_dmask) - 1); if (rv < 0) { fprintf(stdout, "cannot read %s: %s\n", WAKELOCK_DEBUG_MASK_NODE, strerror(-rv)); goto suspend_test_bailout; } wakelock_dmask[rv] = '\0'; fprintf(stdout, "Turn on additional wakelock debug info\n"); rv = write_string_to_file( NULL, WAKELOCK_DEBUG_MASK_NODE, "22\n"); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", WAKELOCK_DEBUG_MASK_NODE, strerror(-rv)); goto suspend_test_bailout; } fprintf(stdout, "Add wakelock to hold off suspend till we suspend ourselves\n"); rv = write_string_to_file( NULL, WAKELOCK_LOCK_NODE, SUSPENDPC_WAKELOCK); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", WAKELOCK_LOCK_NODE, strerror(-rv)); goto suspend_test_bailout; } } fprintf(stdout, "Save current earlysuspend debug mask\n"); rv = read_from_file( NULL, EARLYSUSPEND_DEBUG_MASK_NODE, earlysuspend_dmask, sizeof(earlysuspend_dmask) - 1); if (rv < 0) { fprintf(stdout, "cannot read %s: %s\n", EARLYSUSPEND_DEBUG_MASK_NODE, strerror(-rv)); goto suspend_test_bailout; } earlysuspend_dmask[rv] = '\0'; fprintf(stdout, "turn on early suspend logs\n"); rv = write_string_to_file( NULL, EARLYSUSPEND_DEBUG_MASK_NODE, "5\n"); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", EARLYSUSPEND_DEBUG_MASK_NODE, strerror(-rv)); goto suspend_test_bailout; } fprintf(stdout, "Check whether power management is up\n"); if (!file_exists(PM_STATS_NODE)) { fprintf(stdout, "power management is not available\n"); goto suspend_test_bailout; } fprintf(stdout, "Determine the power management module\n"); if (directory_exists(SYS_PM_8x60)) { g_sys_pm = SYS_PM_8x60; if (file_exists_with_prefix(SYS_PM_8x60, SLEEP_MODE_NODE_CORE_3)) num_cores = 4; else if (file_exists_with_prefix(SYS_PM_8x60, SLEEP_MODE_NODE_CORE_1)) num_cores = 2; else num_cores = 1; } else { fprintf(stdout, "power management is not available\n"); goto suspend_test_bailout; } fprintf(stdout, "Delay tests for some time for usb cable to be plugged out\n"); if (g_delay_test_sec) { unsigned int seconds = g_delay_test_sec; while (seconds) seconds = sleep(seconds); } /* * check if the usb wakelock has been released before * proceeding with the test */ if (g_wakelock_exists) { /* * capture the usb wakelock stats */ rv = read_from_file(NULL, WAKELOCK_NODE, g_wakelock_stats, sizeof(g_wakelock_stats) - 1); usb_active = parse_wakelock_stats_for_active_wl( g_wakelock_stats, "\"msm_otg\""); if (usb_active != 0) { fprintf(stdout, " the usb wakelock is still held by the system\n"); goto suspend_test_bailout; } } /* * determine resume command */ do { rv = write_string_to_file(NULL, POWER_NODE, POWER_STANDBY); if (rv > 0) { g_resume_command = POWER_STANDBY; break; } rv = write_string_to_file( NULL, POWER_NODE, POWER_ON); if (rv > 0) { g_resume_command = POWER_ON; break; } fprintf(stdout, "cannot write to %s: %s\n", POWER_NODE, strerror(-rv)); goto suspend_test_bailout; } while (0); fprintf(stdout, "Set suspend configuration\n"); if (num_cores == 4) { write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_0, 1); write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_1, 1); write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_2, 1); write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_3, 1); } else if (num_cores == 2) { write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_0, 1); write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_1, 1); } else if (num_cores == 1) { write_int_to_file(g_sys_pm, SLEEP_MODE_NODE_CORE_0, 1); } fprintf(stdout, "Turn off idle power collapse and mp-decision\n"); if ((num_cores == 2) || (num_cores == 4)) { if (num_cores == 4) { write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_2, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_3, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_2, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_3, 0); } write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_0, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_1, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_0, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_1, 0); fprintf(stdout, "Turn off mp-decision before testing suspend\n"); rv = fork_exec("stop", "mpdecision", NULL, NULL, 0); if (rv < 0) { fprintf(stdout, "cannot turn off mp-decision: %s\n", strerror(-rv)); goto suspend_test_bailout; } fprintf(stdout, "Now explicitly turn ON core 1 if not ON already\n"); core1_status = read_unsigned_int_from_file(NULL, HOTPLUG_NODE_CORE_1); fprintf(stdout, "core1_status = %d\n", core1_status); if (!core1_status) { fprintf(stdout, "turning on core 1\n"); rv = write_int_to_file(NULL, HOTPLUG_NODE_CORE_1, 1); } if (num_cores == 4) { fprintf(stdout, "Now explicitly turn ON core 2 if not ON already\n"); core2_status = read_unsigned_int_from_file(NULL, HOTPLUG_NODE_CORE_2); fprintf(stdout, "core2_status = %d\n", core2_status); if (!core2_status) { fprintf(stdout, "turning on core 2\n"); rv = write_int_to_file(NULL, HOTPLUG_NODE_CORE_2, 1); } fprintf(stdout, "Now explicitly turn ON core 3 if not ON already\n"); core3_status = read_unsigned_int_from_file(NULL, HOTPLUG_NODE_CORE_3); fprintf(stdout, "core3_status = %d\n", core3_status); if (!core3_status) { fprintf(stdout, "turning on core 3\n"); rv = write_int_to_file(NULL, HOTPLUG_NODE_CORE_3, 1); } } } else if (num_cores == 1) { write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_0, 0); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_0, 0); } fprintf(stdout, "Clear kernel log\n"); rv = fork_exec("dmesg", "-c", NULL, NULL, 1); if (rv < 0) { fprintf(stdout, "dmesg -c failed: %s\n", strerror(-rv)); goto suspend_test_bailout; } fprintf(stdout, "Clear power management stats\n"); rv = write_string_to_file(NULL, PM_STATS_NODE, "reset\n"); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", PM_STATS_NODE, strerror(-rv)); goto suspend_test_bailout; } fprintf(stdout, "Set wakeup time\n"); rv = write_int_to_file( g_sys_pm, SLEEP_TIME_OVERRIDE_NODE, g_wakeup_sec); if (rv < 0) { fprintf(stdout, "cannot write to %s%s: %s\n", g_sys_pm, SLEEP_TIME_OVERRIDE_NODE, strerror(-rv)); goto suspend_test_bailout; } if (g_wakelock_exists) { fprintf(stdout, "Remove the suspend wakelock before issuing the suspend command\n"); rv = write_string_to_file( NULL, WAKELOCK_UNLOCK_NODE, SUSPENDPC_WAKELOCK); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", WAKELOCK_UNLOCK_NODE, strerror(-rv)); goto suspend_test_bailout; } } for (i = 0; i < g_num_iter; i++) { msg("beginning iteration %d for suspend\n", i); fprintf(stdout, "Determine expiration time\n"); now = time(NULL); if (now == (time_t)-1) { fprintf(stdout, "time() failed: %s\n", strerror(errno)); continue; } expiration = now + g_timeout_sec; fprintf(stdout, "Issue suspend command\n"); rv = write_string_to_file(NULL, POWER_NODE, "mem\n"); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", POWER_NODE, strerror(-rv)); i++; goto suspend_test_late_bailout; } k = 0; do { usleep(300 * 1000); if (k % 10 == 0) { fprintf(stdout, "load power management stats\n"); } rv = read_from_file(NULL, PM_STATS_NODE, g_pm_stats, sizeof(g_pm_stats) - 1); if (rv < 0) { fprintf(stdout, "cannot read %s: %s\n", PM_STATS_NODE, strerror(-rv)); goto suspend_test_bailout_cur_iter; } if (rv == sizeof(g_pm_stats) - 1) { fprintf(stdout, "buffer too small for %s\n", PM_STATS_NODE); i++; goto suspend_test_late_bailout; } g_pm_stats[rv] = '\0'; if (k % 10 == 0) { fprintf(stdout, "Look for suspend event\n"); } success_count = parse_pm_stats_count(g_pm_stats, "\n[cpu 0] suspend:\n count: "); if (success_count < 0 ) { fprintf(stdout, "bad count(s) from " "power management stats\n"); i++; goto suspend_test_late_bailout; } if (success_count > num_success) break; if (k % 10 == 0) { fprintf(stdout, "Check timeout\n"); } now = time(NULL); if (now == (time_t)-1) { fprintf(stdout, "time() failed: %s\n", strerror(errno)); goto suspend_test_bailout_cur_iter; } k++; } while (now < expiration); suspend_test_bailout_cur_iter: if (g_resume_command != NULL) { fprintf(stdout, "Issue resume command\n"); rv = write_string_to_file( NULL, POWER_NODE, g_resume_command); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", POWER_NODE, strerror(-rv)); i++; goto suspend_test_late_bailout; } } if (success_count > num_success) { fprintf(stdout, "Suspend/resume succeeded on iteration %d\n", i + 1); msg("Suspend/resume succeeded on iteration %d\n", i + 1); num_success++; } if (now >= expiration) { fprintf(stdout, "Suspend/resume timed out on iteration %d\n", i + 1); msg("Suspend/resume timed out on iteration %\n", i + 1); i++; break; } } fprintf(stdout, "====BEGIN power management stats====\n"); fflush(stdout); rv = write_to_fd(STDOUT_FILENO, g_pm_stats, strlen(g_pm_stats)); if (rv < 0) fprintf(stdout, "cannot write out power management stats\n"); fprintf(stdout, "====END power management stats====\n"); if (g_wakelock_exists) { fprintf(stdout, "====BEGIN wakelock stats====\n"); fflush(stdout); rv = fork_exec("cat", WAKELOCK_NODE, NULL, NULL, 0); if (rv < 0) fprintf(stdout, "cannot dump %s\n", WAKELOCK_NODE); fprintf(stdout, "====END wakelock stats====\n"); } suspend_test_late_bailout: if (g_resume_command != NULL) { fprintf(stdout, "Issue resume command\n"); rv = write_string_to_file( NULL, POWER_NODE, g_resume_command); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", POWER_NODE, strerror(-rv)); goto suspend_test_bailout; } } suspend_test_bailout: fprintf(stdout, "Unset wakeup time\n"); rv = write_string_to_file( g_sys_pm, SLEEP_TIME_OVERRIDE_NODE, "0\n"); if ((num_cores == 2) || (num_cores == 4)) { /* restore idle power collapse */ if (num_cores == 4) { write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_2, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_3, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_2, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_3, 1); } write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_0, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_1, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_0, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_1, 1); fprintf(stdout, "Turn mp-decision back on\n"); rv = fork_exec("start", "mpdecision", NULL, NULL, 0); } else if (num_cores == 1) { write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_CORE_0, 1); write_int_to_file(g_sys_pm, IDLE_SLEEP_MODE_NODE_STD_CORE_0, 1); } fprintf(stdout, "Release suspend wakelock\n"); rv = write_string_to_file( NULL, WAKELOCK_UNLOCK_NODE, SUSPENDPC_WAKELOCK); fprintf(stdout, "Restore wakelock debug mask\n"); if (g_wakelock_exists) { rv = write_string_to_file(NULL, WAKELOCK_DEBUG_MASK_NODE, wakelock_dmask); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", WAKELOCK_DEBUG_MASK_NODE, strerror(-rv)); } } fprintf(stdout, "Restore earlysuspend debug mask\n"); rv = write_string_to_file(NULL, EARLYSUSPEND_DEBUG_MASK_NODE, earlysuspend_dmask); if (rv < 0) { fprintf(stdout, "cannot write to %s: %s\n", EARLYSUSPEND_DEBUG_MASK_NODE, strerror(-rv)); } fprintf(stdout, "Restore the sensor settings\n"); fprintf(stdout, "set the sensors data setting\n"); rv = write_string_to_file(NULL, SENSOR_SETTINGS, "1\n"); fprintf(stdout, "sleep for sometime for the sensors daemon to pick up the setting\n"); sleep(2); suspend_test_early_bailout: fprintf(stdout, "====BEGIN kernel log====\n"); fflush(stdout); rv = fork_exec("dmesg", NULL, NULL, NULL, 0); if (rv < 0) fprintf(stdout, "cannot dump kernel log\n"); fprintf(stdout, "====END kernel log====\n"); fprintf(stdout, "====BEGIN userspace log====\n"); fflush(stdout); rv = fork_exec("logcat", "-d", "-v", "time", 0); if (rv < 0) fprintf(stdout, "cannot dump userspace log\n"); fprintf(stdout, "====END userspace log====\n"); fprintf(stdout, "\n Suspend/resume test succeeded %d out of %d times\n", num_success, i); if (num_success == g_num_iter) return EXIT_SUCCESS; else return EXIT_FAILURE; }
void MplayerDisplaySurface::flip( ) { write_to_fd(_fd); }
static void cpio_append_stat (const char *filename, const struct stat *statbuf) { const char *orig_filename = filename; if (*filename == '/') filename++; if (*filename == '\0') filename = "."; if (verbose >= 2) fprintf (stderr, "cpio_append_stat %s 0%o -> %d\n", orig_filename, statbuf->st_mode, out_fd); /* Regular files and symlinks are the only ones that have a "body" * in this cpio entry. */ int has_body = S_ISREG (statbuf->st_mode) || S_ISLNK (statbuf->st_mode); size_t len = strlen (filename) + 1; char header[CPIO_HEADER_LEN + 1]; snprintf (header, sizeof header, "070701" /* magic */ "%08X" /* inode */ "%08X" /* mode */ "%08X" "%08X" /* uid, gid */ "%08X" /* nlink */ "%08X" /* mtime */ "%08X" /* file length */ "%08X" "%08X" /* device holding file major, minor */ "%08X" "%08X" /* for specials, device major, minor */ "%08X" /* name length (including \0 byte) */ "%08X", /* checksum (not used by the kernel) */ (unsigned) statbuf->st_ino, statbuf->st_mode, statbuf->st_uid, statbuf->st_gid, (unsigned) statbuf->st_nlink, (unsigned) statbuf->st_mtime, has_body ? (unsigned) statbuf->st_size : 0, major (statbuf->st_dev), minor (statbuf->st_dev), major (statbuf->st_rdev), minor (statbuf->st_rdev), (unsigned) len, 0); /* Write the header. */ write_to_fd (header, CPIO_HEADER_LEN); /* Follow with the filename, and pad it. */ write_to_fd (filename, len); size_t padding_len = PADDING (CPIO_HEADER_LEN + len); write_padding (padding_len); /* Follow with the file or symlink content, and pad it. */ if (has_body) { if (S_ISREG (statbuf->st_mode)) write_file_len_to_fd (orig_filename, statbuf->st_size); else if (S_ISLNK (statbuf->st_mode)) { char tmp[PATH_MAX]; if (readlink (orig_filename, tmp, sizeof tmp) == -1) error (EXIT_FAILURE, errno, "readlink: %s", orig_filename); write_to_fd (tmp, statbuf->st_size); } padding_len = PADDING (statbuf->st_size); write_padding (padding_len); } }