fixed_queue_t *fixed_queue_new(size_t capacity) {
fixed_queue_t *ret = calloc(1, sizeof(fixed_queue_t));
if (!ret)
goto error;
ret->list = list_new(NULL);
if (!ret->list)
goto error;
ret->enqueue_sem = semaphore_new(capacity);
if (!ret->enqueue_sem)
goto error;
ret->dequeue_sem = semaphore_new(0);
if (!ret->dequeue_sem)
goto error;
pthread_mutex_init(&ret->lock, NULL);
ret->capacity = capacity;
return ret;
error:;
if (ret) {
list_free(ret->list);
semaphore_free(ret->enqueue_sem);
semaphore_free(ret->dequeue_sem);
}
free(ret);
return NULL;
}
/* Establish the file system and write it to disk */
int
fs_format(mem_sblock_t sbp)
{
blocknum_t inode_bitmap_size;
blocknum_t block_bitmap_size;
blocknum_t i;
sbp->filesys_lock = semaphore_new(1);
if (NULL == sbp->filesys_lock) {
return -1;
}
fs_lock(sbp);
/* Format super block */
sblock_get(maindisk, sbp);
sblock_format(sbp, disk_size);
sblock_update(sbp);
/* Format inode and block bitmaps */
inode_bitmap_size = sbp->inode_bitmap_last - sbp->inode_bitmap_first + 1;
sbp->inode_bitmap = malloc(inode_bitmap_size * DISK_BLOCK_SIZE);
block_bitmap_size = sbp->block_bitmap_last - sbp->block_bitmap_first + 1;
sbp->block_bitmap = malloc(block_bitmap_size * DISK_BLOCK_SIZE);
if (NULL == sbp->block_bitmap || NULL == sbp->inode_bitmap) {
semaphore_V(sbp->filesys_lock);
return -1;
}
/* Clear bitmaps */
bitmap_zeroall(sbp->inode_bitmap, inode_bitmap_size * BITS_PER_BLOCK);
bitmap_zeroall(sbp->block_bitmap, block_bitmap_size * BITS_PER_BLOCK);
/* Set file system blocks to be occupied */
for (i = 0; i <= sbp->block_bitmap_last; ++i) {
bitmap_set(sbp->block_bitmap, i);
}
/* Set inode 0 to be occupied */
bitmap_set(sbp->inode_bitmap, 0);
/* Push updates to disk */
for (i = sbp->inode_bitmap_first; i <= sbp->inode_bitmap_last; ++i) {
bpush(i, (char*) sbp->inode_bitmap + (i - sbp->inode_bitmap_first)
* DISK_BLOCK_SIZE);
}
for (i = sbp->block_bitmap_first; i <= sbp->block_bitmap_last; ++i) {
bpush(i, (char*) sbp->block_bitmap + (i - sbp->block_bitmap_first)
* DISK_BLOCK_SIZE);
}
/* Count free inodes and free blocks */
mainsb->free_inodes = bitmap_count_zero(mainsb->inode_bitmap,
mainsb->total_inodes);
mainsb->free_blocks = bitmap_count_zero(mainsb->block_bitmap,
mainsb->disk_num_blocks);
fs_unlock(sbp);
return 0;
}
int main(void)
{
int count;
int semaphore_id;
int g_shm_id;
int *g_shm_addr;
pid_t pid = 1;
pid_t pids[NO_OF_CHILDREN];
semaphore_id = semaphore_new(SEM_KEY);
v(semaphore_id, 1);
g_shm_id = create_shared_memory(SHM_KEY);
g_shm_addr = associate_shared_memory(g_shm_id);
*g_shm_addr = 0;
for (count = 0; count < NO_OF_CHILDREN; count++) {
if (pid) {
if ((pid = fork()) < 0) {
fprintf(stderr, "The fork() function has failed: %s\n", strerror(errno));
return EXIT_FAILURE;
}
pids[count] = pid;
if (pid)
fprintf(stderr, "#%d# Created pid process: %d\n", getpid(), (pids[count]));
}
else
break;
}
if (!pid)
print_characters(semaphore_id, g_shm_addr);
else {
usleep(WAIT_CHILDREN);
printf(NEW_LINE);
for (count = 0; count < NO_OF_CHILDREN; count++) {
kill(pids[count], SIGKILL);
fprintf(stderr, "#%d# Killing pid process: %d\n", getpid(), pids[count]);
}
shared_memory_destroy(g_shm_id);
semaphore_destroy(semaphore_id);
}
exit(EXIT_SUCCESS);
}
static void init(void)
{
semaphore_1 = semaphore_new(SEMAPHORE_1_KEY, 2);
semaphore_2 = semaphore_new(SEMAPHORE_2_KEY, 2);
v(semaphore_1, BUFFER_SIZE, 0);
v(semaphore_2, ONE, 0);
v(semaphore_2, ONE, 1);
/*free_id = semaphore_new(FREE_KEY);
busy_id = semaphore_new(BUSY_KEY);
producer_lock = semaphore_new(PRODUCT_KEY);
consumer_lock = semaphore_new(CONSUMER_KEY);*/
stderr_lock = semaphore_new(STDERR_KEY, 1);
/*v(free_id, BUFFER_SIZE);
v(producer_lock, ONE);
v(consumer_lock, ONE);*/
v(stderr_lock, ONE, 0);
}
int main(int argc, char *argv[])
{
int s, ns;
int semaphore_id;
int shared_memory_id = 0;
uint16_t port;
pid_t pid;
struct sockaddr_in client;
char *tmp_shm_addr;
shm_t *g_shm;
check_args(&argc, argv, 0);
port = (uint16_t) atoi(argv[1]);
create_tcp_socket(&s, port);
semaphore_id = semaphore_new(SEM_KEY);
v(semaphore_id, 1);
shared_memory_id = create_shared_memory(SHM_KEY);
tmp_shm_addr = associate_shared_memory(shared_memory_id);
g_shm = (shm_t *) tmp_shm_addr;
while (true) {
accept_new_connection(&s, &ns, &client);
if ((pid = fork()) == 0)
shandler(&ns, semaphore_id, client, g_shm);
else {
if (pid > 0)
fprintf(stderr, "#%d# Father - Created child process: %d\n", getpid(), pid);
else {
fprintf(stderr, "The fork() function has failed: %s!\n", strerror(errno));
shared_memory_destroy(shared_memory_id);
semaphore_destroy(semaphore_id);
exit(EXIT_FAILURE);
}
}
}
shared_memory_destroy(shared_memory_id);
semaphore_destroy(semaphore_id);
exit(EXIT_SUCCESS);
}
/* Initialize the file system structure from disk */
int
fs_init(mem_sblock_t sbp)
{
blocknum_t inode_bitmap_size;
blocknum_t block_bitmap_size;
blocknum_t i;
sbp->filesys_lock = semaphore_new(1);
if (NULL == sbp->filesys_lock) {
return -1;
}
fs_lock(sbp);
sblock_get(maindisk, sbp);
sblock_put(sbp);
if (sblock_isvalid(sbp) != 1) {
sblock_print(sbp);
kprintf("File system is not recognized. ");
kprintf("Recommend running './mkfs <blocks>'.\n");
return -2;
}
inode_bitmap_size = sbp->inode_bitmap_last - sbp->inode_bitmap_first + 1;
sbp->inode_bitmap = malloc(inode_bitmap_size * DISK_BLOCK_SIZE);
block_bitmap_size = sbp->block_bitmap_last - sbp->block_bitmap_first + 1;
sbp->block_bitmap = malloc(block_bitmap_size * DISK_BLOCK_SIZE);
if (NULL == sbp->block_bitmap || NULL == sbp->inode_bitmap) {
semaphore_V(sbp->filesys_lock);
return -1;
}
/* Get disk bitmap */
for (i = sbp->inode_bitmap_first; i <= sbp->inode_bitmap_last; ++i) {
bpull(i, (char*) sbp->inode_bitmap + (i - sbp->inode_bitmap_first)
* DISK_BLOCK_SIZE);
}
for (i = sbp->block_bitmap_first; i <= sbp->block_bitmap_last; ++i) {
bpull(i, (char*) sbp->block_bitmap + (i - sbp->block_bitmap_first)
* DISK_BLOCK_SIZE);
}
/* Count free inodes and free blocks */
mainsb->free_inodes = bitmap_count_zero(mainsb->inode_bitmap,
mainsb->total_inodes);
mainsb->free_blocks = bitmap_count_zero(mainsb->block_bitmap,
mainsb->disk_num_blocks);
fs_unlock(sbp);
return 0;
}
thread_t *thread_new_sized(const char *name, size_t work_queue_capacity) {
assert(name != NULL);
assert(work_queue_capacity != 0);
thread_t *ret = osi_calloc(sizeof(thread_t));
if (!ret)
goto error;
ret->reactor = reactor_new();
if (!ret->reactor)
goto error;
ret->work_queue = fixed_queue_new(work_queue_capacity);
if (!ret->work_queue)
goto error;
// Start is on the stack, but we use a semaphore, so it's safe
struct start_arg start;
start.start_sem = semaphore_new(0);
if (!start.start_sem)
goto error;
strncpy(ret->name, name, THREAD_NAME_MAX);
start.thread = ret;
start.error = 0;
pthread_create(&ret->pthread, NULL, run_thread, &start);
semaphore_wait(start.start_sem);
semaphore_free(start.start_sem);
if (start.error)
goto error;
return ret;
error:;
if (ret) {
fixed_queue_free(ret->work_queue, osi_free);
reactor_free(ret->reactor);
}
osi_free(ret);
return NULL;
}
thread_t *thread_new(const char *name) {
assert(name != NULL);
// Start is on the stack, but we use a semaphore, so it's safe
thread_t *ret = calloc(1, sizeof(thread_t));
if (!ret)
goto error;
ret->reactor = reactor_new();
if (!ret->reactor)
goto error;
ret->work_queue = fixed_queue_new(WORK_QUEUE_CAPACITY);
if (!ret->work_queue)
goto error;
struct start_arg start;
start.start_sem = semaphore_new(0);
if (!start.start_sem)
goto error;
strncpy(ret->name, name, THREAD_NAME_MAX);
start.thread = ret;
start.error = 0;
pthread_create(&ret->pthread, NULL, run_thread, &start);
semaphore_wait(start.start_sem);
semaphore_free(start.start_sem);
if (start.error)
goto error;
return ret;
error:;
if (ret) {
fixed_queue_free(ret->work_queue, free);
reactor_free(ret->reactor);
}
free(ret);
return NULL;
}
static bool lazy_initialize(void) {
assert(alarms == NULL);
pthread_mutex_init(&monitor, NULL);
alarms = list_new(NULL);
if (!alarms) {
LOG_ERROR("%s unable to allocate alarm list.", __func__);
return false;
}
struct sigevent sigevent;
memset(&sigevent, 0, sizeof(sigevent));
sigevent.sigev_notify = SIGEV_THREAD;
sigevent.sigev_notify_function = (void (*)(union sigval))timer_callback;
if (timer_create(CLOCK_ID, &sigevent, &timer) == -1) {
LOG_ERROR("%s unable to create timer: %s", __func__, strerror(errno));
return false;
}
alarm_expired = semaphore_new(0);
if (!alarm_expired) {
LOG_ERROR("%s unable to create alarm expired semaphore", __func__);
return false;
}
callback_thread_active = true;
callback_thread = thread_new("alarm_callbacks");
if (!callback_thread) {
LOG_ERROR("%s unable to create alarm callback thread.", __func__);
return false;
}
thread_set_priority(callback_thread, CALLBACK_THREAD_PRIORITY_HIGH);
thread_post(callback_thread, callback_dispatch, NULL);
return true;
}
int main(int argc, char**argv)
{
GtkWidget *hboxg, *vbox1,*vbox2;
/*Inicialización de variables y semaforos*/
sfd = 0;
connected = 0;
in_channel = 0;
queried = 0;
port = 0;
server_called = 0;
readers_num = 0;
their_calling_port = 0;
if ((readers = semaphore_new()) == ERROR){
syslog(LOG_ERR, "Failed while creating a new semaphore: %s\n", strerror(errno));
return EXIT_FAILURE;
}
if ((writer = semaphore_new()) == ERROR){
syslog(LOG_ERR, "Failed while creating a new semaphore: %s\n", strerror(errno));
semaphore_rm(readers);
return EXIT_FAILURE;
}
if ((mutex_access = semaphore_new()) == ERROR){
syslog(LOG_ERR, "Failed while creating a new semaphore: %s\n", strerror(errno));
semaphore_rm(readers);
semaphore_rm(writer);
return EXIT_FAILURE;
}
if ((mutex_rvariables = semaphore_new()) == ERROR){
syslog(LOG_ERR, "Failed while creating a new semaphore: %s\n", strerror(errno));
semaphore_rm(readers);
semaphore_rm(writer);
semaphore_rm(mutex_access);
return EXIT_FAILURE;
}
g_type_init (); /* Necesario para tener funcionalidad de hilos */
gdk_threads_init ();
gdk_threads_enter ();
gtk_init(&argc, &argv); /* Inicia gnome */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* Ventana principal */
gtk_window_set_title(GTK_WINDOW(window), "IRC Chat"); /* Título ventana principal */
gtk_window_set_default_size(GTK_WINDOW(window), 800, 350); /* Tamaño ventana principal */
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); /* Posición ventana principal */
/* Estructura global */
hboxg = gtk_hbox_new(FALSE,5);
vbox1 = gtk_vbox_new(FALSE,5);
vbox2 = gtk_vbox_new(FALSE,5);
gtk_container_add(GTK_CONTAINER(window), hboxg);
gtk_box_pack_start(GTK_BOX(hboxg), vbox1,FALSE,FALSE,1);
gtk_box_pack_start(GTK_BOX(hboxg), vbox2,FALSE,FALSE,1);
ConnectArea(vbox1);
StateArea(vbox1);
ChatArea(vbox2);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(ordered_exit), NULL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window); /* Presentación de las ventanas */
gdk_threads_leave (); /* Salida de hilos */
gtk_main(); /* Administración de la interacción */
return 0;
}