fdo-mirrors/plymouth
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/plymouth/plymouth.git synced 2026-05-08 08:58:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Random spacing clean ups

Browse source
This commit is contained in:
Ray Strode 2008-05-28 08:50:09 -04:00
parent 943ff6268c
commit a93fd30a47
4 changed files with 68 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

88
src/libply/ply-event-loop.c
View file

@ -41,7 +41,7 @@
#include "ply-list.h"
#include "ply-utils.h"
#ifndef PLY_EVENT_LOOP_NUM_EVENT_HANDLERS
#ifndef PLY_EVENT_LOOP_NUM_EVENT_HANDLERS
#define PLY_EVENT_LOOP_NUM_EVENT_HANDLERS 64
#endif
@ -51,7 +51,7 @@
typedef struct
{
int fd;
int fd;
ply_list_t *destinations;
ply_list_t *fd_watches;
uint32_t is_getting_polled : 1;
@ -63,7 +63,7 @@ typedef struct
ply_event_source_t *source;
ply_event_loop_fd_status_t status;
ply_event_handler_t status_met_handler;
ply_event_handler_t status_met_handler;
ply_event_handler_t disconnected_handler;
void *user_data;
} ply_event_destination_t;
@ -105,17 +105,17 @@ typedef struct
struct _ply_event_loop
{
int epoll_fd;
int exit_code;
int epoll_fd;
int exit_code;
double wakeup_time;
ply_list_t *sources;
ply_list_t *exit_closures;
ply_list_t *timeout_watches;
ply_signal_dispatcher_t *signal_dispatcher;
ply_signal_dispatcher_t *signal_dispatcher;
uint32_t should_exit : 1;
uint32_t should_exit : 1;
};
static void ply_event_loop_process_pending_events (ply_event_loop_t *loop);
@ -153,12 +153,12 @@ ply_signal_source_free (ply_signal_source_t *handler)
free (handler);
}
static ply_signal_dispatcher_t *
ply_signal_dispatcher_new (void)
{
ply_signal_dispatcher_t *dispatcher;
if (!ply_open_unidirectional_pipe (&ply_signal_dispatcher_sender_fd,
&ply_signal_dispatcher_receiver_fd))
return NULL;
@ -209,7 +209,7 @@ ply_signal_dispatcher_posix_signal_handler (int signal_number)
if (ply_signal_dispatcher_sender_fd < 0)
return;
ply_write (ply_signal_dispatcher_sender_fd, &signal_number,
ply_write (ply_signal_dispatcher_sender_fd, &signal_number,
sizeof (signal_number));
}
@ -218,7 +218,7 @@ ply_signal_dispatcher_get_next_signal_from_pipe (ply_signal_dispatcher_t *dispat
{
int signal_number;
if (!ply_read (ply_signal_dispatcher_receiver_fd, &signal_number,
if (!ply_read (ply_signal_dispatcher_receiver_fd, &signal_number,
sizeof (signal_number)))
signal_number = 0;
@ -243,7 +243,7 @@ ply_signal_dispatcher_dispatch_signal (ply_signal_dispatcher_t *dispatcher,
source = (ply_signal_source_t *) ply_list_node_get_data (node);
if (source->signal_number == signal_number)
if (source->signal_number == signal_number)
{
if (source->handler != NULL)
source->handler (source->user_data, signal_number);
@ -266,7 +266,7 @@ ply_signal_dispatcher_reset_signal_sources (ply_signal_dispatcher_t *dispatcher,
handler = (ply_signal_source_t *) ply_list_node_get_data (node);
signal (handler->signal_number,
signal (handler->signal_number,
handler->old_posix_signal_handler != NULL?
handler->old_posix_signal_handler : SIG_DFL);
@ -372,13 +372,13 @@ ply_event_loop_update_source_event_mask (ply_event_loop_t *loop,
destination = (ply_event_destination_t *) ply_list_node_get_data (node);
next_node = ply_list_get_next_node (source->destinations, node);
if (destination->status & PLY_EVENT_LOOP_FD_STATUS_HAS_DATA)
if (destination->status & PLY_EVENT_LOOP_FD_STATUS_HAS_DATA)
event.events |= EPOLLIN;
if (destination->status & PLY_EVENT_LOOP_FD_STATUS_HAS_CONTROL_DATA)
if (destination->status & PLY_EVENT_LOOP_FD_STATUS_HAS_CONTROL_DATA)
event.events |= EPOLLPRI;
if (destination->status & PLY_EVENT_LOOP_FD_STATUS_CAN_TAKE_DATA)
if (destination->status & PLY_EVENT_LOOP_FD_STATUS_CAN_TAKE_DATA)
event.events |= EPOLLOUT;
node = next_node;
@ -439,7 +439,7 @@ ply_event_loop_remove_destination_by_fd_watch (ply_event_loop_t *loop,
{
ply_event_destination_t *destination;
ply_event_source_t *source;
assert (loop != NULL);
assert (watch != NULL);
@ -478,7 +478,7 @@ ply_event_loop_new (void)
if (loop->signal_dispatcher == NULL)
return NULL;
ply_event_loop_watch_fd (loop,
ply_event_loop_watch_fd (loop,
ply_signal_dispatcher_receiver_fd,
PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,
(ply_event_handler_t)
@ -563,7 +563,7 @@ ply_event_loop_find_source_node (ply_event_loop_t *loop,
ply_event_source_t *source;
source = (ply_event_source_t *) ply_list_node_get_data (node);
if (source->fd == fd)
break;
@ -759,7 +759,7 @@ ply_signal_dispatcher_find_source_node (ply_signal_dispatcher_t *dispatcher,
handler = (ply_signal_source_t *) ply_list_node_get_data (node);
assert (handler != NULL);
if (handler->signal_number == signal_number)
break;
@ -781,7 +781,7 @@ ply_event_loop_watch_signal (ply_event_loop_t *loop,
signal_handler,
user_data);
source->old_posix_signal_handler =
source->old_posix_signal_handler =
signal (signal_number, ply_signal_dispatcher_posix_signal_handler);
ply_list_append_data (loop->signal_dispatcher->sources, source);
}
@ -794,7 +794,7 @@ ply_signal_dispatcher_remove_source_node (ply_signal_dispatcher_t *dispatcher,
source = (ply_signal_source_t *) ply_list_node_get_data (node);
signal (source->signal_number,
signal (source->signal_number,
source->old_posix_signal_handler != NULL?
source->old_posix_signal_handler : SIG_DFL);
@ -815,7 +815,7 @@ ply_event_loop_stop_watching_signal (ply_event_loop_t *loop,
ply_signal_dispatcher_remove_source_node (loop->signal_dispatcher, node);
}
void
void
ply_event_loop_watch_for_exit (ply_event_loop_t *loop,
ply_event_loop_exit_handler_t exit_handler,
void *user_data)
@ -860,7 +860,7 @@ ply_event_loop_stop_watching_for_exit (ply_event_loop_t *loop,
void
ply_event_loop_watch_for_timeout (ply_event_loop_t *loop,
double seconds,
double seconds,
ply_event_loop_timeout_handler_t timeout_handler,
void *user_data)
{
@ -909,14 +909,14 @@ ply_event_loop_stop_watching_for_timeout (ply_event_loop_t *loop,
}
}
static ply_event_loop_fd_status_t
static ply_event_loop_fd_status_t
ply_event_loop_get_fd_status_from_poll_mask (uint32_t mask)
{
ply_event_loop_fd_status_t status;
status = PLY_EVENT_LOOP_FD_STATUS_NONE;
if (mask & EPOLLIN)
if (mask & EPOLLIN)
status |= PLY_EVENT_LOOP_FD_STATUS_HAS_DATA;
if (mask & EPOLLPRI)
@ -946,7 +946,7 @@ ply_event_loop_source_has_met_status (ply_event_source_t *source,
destination = (ply_event_destination_t *) ply_list_node_get_data (node);
next_node = ply_list_get_next_node (source->destinations, node);
if (((destination->status & status) != 0)
if (((destination->status & status) != 0)
&& (destination->status_met_handler != NULL))
return true;
@ -975,7 +975,7 @@ ply_event_loop_handle_met_status_for_source (ply_event_loop_t *loop,
destination = (ply_event_destination_t *) ply_list_node_get_data (node);
next_node = ply_list_get_next_node (source->destinations, node);
if (((destination->status & status) != 0)
if (((destination->status & status) != 0)
&& (destination->status_met_handler != NULL))
destination->status_met_handler (destination->user_data, source->fd);
@ -1080,7 +1080,7 @@ ply_event_loop_free_destinations_for_source (ply_event_loop_t *loop,
next_node = ply_list_get_next_node (source->destinations, node);
destination =
destination =
(ply_event_destination_t *) ply_list_node_get_data (node);
assert (destination != NULL);
@ -1096,7 +1096,7 @@ ply_event_loop_disconnect_source (ply_event_loop_t *loop,
{
ply_event_loop_handle_disconnect_for_source (loop, source);
/* at this point, we've told the event loop users about the
/* at this point, we've told the event loop users about the
* fd disconnection, so we can invalidate any outstanding
* watches and free the destinations.
*/
@ -1150,10 +1150,10 @@ ply_event_loop_process_pending_events (ply_event_loop_t *loop)
assert (loop != NULL);
if (events == NULL)
events =
events =
malloc (PLY_EVENT_LOOP_NUM_EVENT_HANDLERS * sizeof (struct epoll_event));
memset (events, -1,
memset (events, -1,
PLY_EVENT_LOOP_NUM_EVENT_HANDLERS * sizeof (struct epoll_event));
do
@ -1181,7 +1181,7 @@ ply_event_loop_process_pending_events (ply_event_loop_t *loop)
return;
}
}
}
}
while ((number_of_received_events < 0) && (errno == EINTR));
for (i = 0; i < number_of_received_events; i++)
@ -1220,7 +1220,7 @@ ply_event_loop_process_pending_events (ply_event_loop_t *loop)
}
void
ply_event_loop_exit (ply_event_loop_t *loop,
ply_event_loop_exit (ply_event_loop_t *loop,
int exit_code)
{
assert (loop != NULL);
@ -1292,7 +1292,7 @@ on_timeout (ply_event_loop_t *loop)
}
int
main (int argc,
main (int argc,
char **argv)
{
int exit_code;
@ -1300,19 +1300,19 @@ main (int argc,
loop = ply_event_loop_new ();
ply_event_loop_watch_signal (loop, SIGHUP,
(ply_event_handler_t) hangup_signal_handler,
NULL);
(ply_event_handler_t) hangup_signal_handler,
NULL);
ply_event_loop_watch_signal (loop, SIGTERM,
(ply_event_handler_t)
terminate_signal_handler, NULL);
(ply_event_handler_t)
terminate_signal_handler, NULL);
ply_event_loop_watch_signal (loop, SIGUSR1,
(ply_event_handler_t)
usr1_signal_handler, NULL);
(ply_event_handler_t)
usr1_signal_handler, NULL);
ply_event_loop_watch_signal (loop, SIGALRM,
(ply_event_handler_t)
alrm_signal_handler, NULL);
(ply_event_handler_t)
alrm_signal_handler, NULL);
ply_event_loop_watch_for_timeout (loop, 2.0,
ply_event_loop_watch_for_timeout (loop, 2.0,
(ply_event_loop_timeout_handler_t)
on_timeout, loop);
ply_event_loop_watch_fd (loop, 0, PLY_EVENT_LOOP_FD_STATUS_HAS_DATA,

17
src/libply/ply-frame-buffer.c
View file

@ -315,8 +315,8 @@ ply_frame_buffer_fill_area_with_pixel_value (ply_frame_buffer_t *buffer,
static void
ply_frame_buffer_area_union (ply_frame_buffer_area_t *area1,
ply_frame_buffer_area_t *area2,
ply_frame_buffer_area_t *result)
ply_frame_buffer_area_t *area2,
ply_frame_buffer_area_t *result)
{
unsigned long x1, y1, x2, y2;
@ -329,7 +329,7 @@ ply_frame_buffer_area_union (ply_frame_buffer_area_t *area1,
result->y = MIN(area1->y, area2->y);
result->width = MAX(x1, x2) - result->x;
result->height = MAX(y1, y2) - result->y;
}
}
static void
ply_frame_buffer_add_area_to_flush_area (ply_frame_buffer_t *buffer,
@ -345,8 +345,8 @@ ply_frame_buffer_add_area_to_flush_area (ply_frame_buffer_t *buffer,
assert (area->height >= 0);
ply_frame_buffer_area_union (&buffer->area_to_flush,
area,
&buffer->area_to_flush);
area,
&buffer->area_to_flush);
}
static bool
@ -361,7 +361,9 @@ ply_frame_buffer_copy_to_device (ply_frame_buffer_t *buffer,
size_t bytes_per_row;
bytes_per_row = width * buffer->bytes_per_pixel;
row_buffer = malloc (buffer->row_stride * buffer->bytes_per_pixel);
for (row = y; row < y + height; row++)
{
unsigned long offset;
@ -572,8 +574,8 @@ ply_frame_buffer_get_size (ply_frame_buffer_t *buffer,
static void
ply_frame_buffer_area_intersect (ply_frame_buffer_area_t *area1,
ply_frame_buffer_area_t *area2,
ply_frame_buffer_area_t *result)
ply_frame_buffer_area_t *area2,
ply_frame_buffer_area_t *result)
{
unsigned long x1, y1, x2, y2;
@ -584,6 +586,7 @@ ply_frame_buffer_area_intersect (ply_frame_buffer_area_t *area1,
result->x = MAX(area1->x, area2->x);
result->y = MAX(area1->y, area2->y);
result->width = MIN(x1, x2) - result->x;
result->height = MIN(y1, y2) - result->y;
}

16
src/libply/ply-list.c
View file

@ -56,10 +56,10 @@ ply_list_new (void)
return list;
}
void
void
ply_list_free (ply_list_t *list)
{
ply_list_node_t *node;
ply_list_node_t *node;
if (list == NULL)
return;
@ -87,7 +87,7 @@ ply_list_node_new (void *data)
return node;
}
void
void
ply_list_node_free (ply_list_node_t *node)
{
if (node == NULL)
@ -98,7 +98,7 @@ ply_list_node_free (ply_list_node_t *node)
free (node);
}
int
int
ply_list_get_length (ply_list_t *list)
{
return list->number_of_nodes;
@ -133,7 +133,7 @@ ply_list_insert_node (ply_list_t *list,
if (node_before == NULL)
{
if (list->first_node == NULL)
{
{
assert (list->last_node == NULL);
list->first_node = new_node;
@ -189,7 +189,7 @@ ply_list_prepend_data (ply_list_t *list,
return ply_list_insert_data (list, data, NULL);
}
void
void
ply_list_remove_data (ply_list_t *list,
void *data)
{
@ -204,7 +204,7 @@ ply_list_remove_data (ply_list_t *list,
ply_list_remove_node (list, node);
}
static void
static void
ply_list_unlink_node (ply_list_t *list,
ply_list_node_t *node)
{
@ -240,7 +240,7 @@ ply_list_unlink_node (ply_list_t *list,
assert (ply_list_find_node (list, node->data) == NULL);
}
void
void
ply_list_remove_node (ply_list_t *list,
ply_list_node_t *node)
{

12
src/main.c
View file

@ -87,9 +87,9 @@ on_session_finished (state_t *state)
ply_log ("\nSession finished...exiting logger\n");
ply_flush_log ();
ply_event_loop_exit (state->loop, 1);
}
}
static void
static void
on_update (state_t *state,
const char *status)
{
@ -137,7 +137,7 @@ on_system_initialized (state_t *state)
ply_trace ("system now initialized, ready to mount root filesystem");
mknod ("/dev/root", 0600 | S_IFBLK, makedev (253, 0));
mount("/dev/root", "/sysroot", "ext3", 0, NULL);
ply_terminal_session_open_log (state->session,
ply_terminal_session_open_log (state->session,
"/sysroot/var/log/bootmessages.log");
}
@ -270,7 +270,7 @@ start_boot_splash (state_t *state,
}
static ply_terminal_session_t *
spawn_session (state_t *state,
spawn_session (state_t *state,
char **argv)
{
ply_terminal_session_t *session;
@ -430,7 +430,7 @@ static bool
copy_data_files (state_t *state)
{
ply_trace ("copying data files");
if (!ply_copy_directory ("/usr/share/plymouth",
if (!ply_copy_directory ("/usr/share/plymouth",
"usr/share/plymouth"))
return false;
ply_trace ("copied data files");
@ -505,7 +505,7 @@ main (int argc,
state.loop = ply_event_loop_new ();
/* before do anything we need to make sure we have a working
/* before do anything we need to make sure we have a working
* environment. /proc needs to be mounted and certain devices need
* to be accessible (like the framebuffer device, pseudoterminal
* devices, etc)