/*
 * thread_synchronization.c
 * 
 * Copyright 2012 叶剑飞
 *
 * Compile command:
 *    gcc thread_synchronization.c -o thread_synchronization -std=gnu99 -pedantic -D_REENTRANT -lpthread -Wall
 * 
 */


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
#include <time.h>

typedef int COUNT;

sem_t p12, p13, p24, p25, p35, p46, p56;
int maxLoop[7];

void * thread1 ( void * args )
{
    for ( COUNT i = 0 ; i < maxLoop[1] ; i ++ )
    {
        puts( "I am thread one." );
        usleep(500000);
    }
    sem_post( &p12 );
    sem_post( &p13 );
    return NULL;
}

void * thread2 ( void * args )
{
    sem_wait( &p12 );
    for ( COUNT i = 0 ; i < maxLoop[2] ; i ++ )
    {
        puts( "I am thread two." );
        usleep(500000);
    }
    sem_post( &p24 );
    sem_post( &p25 );
    return NULL;
}

void * thread3 ( void * args )
{
    sem_wait( &p13 );
    for ( COUNT i = 0 ; i < maxLoop[3] ; i ++ )
    {
        puts( "I am thread three." );
        usleep(500000);
    }
    sem_post( &p35 );
    return NULL;
}

void * thread4 ( void * args )
{
    sem_wait( &p24 );
    for ( COUNT i = 0 ; i < maxLoop[4] ; i ++ )
    {
        puts( "I am thread four." );
        usleep(500000);
    }
    sem_post( &p46 );
    return NULL;
}

void * thread5 ( void * args )
{
    sem_wait( &p25 );
    sem_wait( &p35 );
    for ( COUNT i = 0 ; i < maxLoop[5] ; i ++ )
    {
        puts( "I am thread five." );
        usleep(500000);
    }
    sem_post( &p56 );
    return NULL;
}

void * thread6 ( void * args )
{
    sem_wait( &p46 );
    sem_wait( &p56 );
    for ( COUNT i = 0 ; i < maxLoop[6] ; i ++ )
    {
        puts( "I am thread six." );
        usleep(500000);
    }
    return NULL;
}

int main (void)
{
    pthread_t threadid[7];
    const int n = 10;

    srand( time(NULL) );

    for ( COUNT i = 1 ; i < 7 ; i ++ )
        maxLoop[i] = (rand() % n) + 1;

    if ( sem_init( &p12, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }
    if ( sem_init( &p13, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }
    if ( sem_init( &p24, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }
    if ( sem_init( &p25, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }
    if ( sem_init( &p35, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }
    if ( sem_init( &p46, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }
    if ( sem_init( &p56, 0, 0 ) == -1 )
    {
        fprintf( stderr, "Error Initializing Semaphore\n\n");
        return EXIT_FAILURE;
    }

    if ( pthread_create( &threadid[1], NULL, thread1, NULL ) )
    {
        fprintf( stderr, "Error Creating Thread.\n\n" );
        return EXIT_FAILURE;
    }
    if ( pthread_create( &threadid[2], NULL, thread2, NULL ) )
    {
        fprintf( stderr, "Error Creating Thread.\n\n" );
        return EXIT_FAILURE;
    }
    if ( pthread_create( &threadid[3], NULL, thread3, NULL ) )
    {
        fprintf( stderr, "Error Creating Thread.\n\n" );
        return EXIT_FAILURE;
    }
    if ( pthread_create( &threadid[4], NULL, thread4, NULL ) )
    {
        fprintf( stderr, "Error Creating Thread.\n\n" );
        return EXIT_FAILURE;
    }
    if ( pthread_create( &threadid[5], NULL, thread5, NULL ) )
    {
        fprintf( stderr, "Error Creating Thread.\n\n" );
        return EXIT_FAILURE;
    }
    if ( pthread_create( &threadid[6], NULL, thread6, NULL ) )
    {
        fprintf( stderr, "Error Creating Thread.\n\n" );
        return EXIT_FAILURE;
    }

    for ( COUNT i = 1 ; i < 7 ; i ++ )
    {
        if ( pthread_join( threadid[i] , NULL ) )
        {
            fprintf( stderr, "Error Joining Thread.\n\n" );
            return EXIT_FAILURE;
        }
    }

    return EXIT_SUCCESS;
}

叶剑飞Victor 2013-10-06 17:33 发表评论

/*
 * process_synchronization.c
 * 
 * Copyright 2012 叶剑飞
 *
 * Compile command:
 *        gcc process_synchronization.c -o process_synchronization -std=gnu99 -pedantic -Wall
 * 
 */


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

typedef int COUNT;

union semun {
    int               val;    /* Value for SETVAL */
    struct semid_ds * buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  * array;  /* Array for GETALL, SETALL */
    struct seminfo  * __buf;  /* Buffer for IPC_INFO
                     (Linux-specific) */
};

int createSemaphore ( void )
{
    int semid;
    union semun arg;
    semid = semget( IPC_PRIVATE, 1, 0666|IPC_CREAT );
    if ( semid == -1 )
        return -1;
    arg.val = 1;
    if ( semctl( semid, 0, SETVAL, arg ) == -1 )
        return -1;
    return semid;
}

bool destroySemaphore ( int semid )
{
    union semun arg;
    if ( semctl( semid, 0, IPC_RMID, arg ) == -1 )
        return false;
    else
        return true;
}

bool P( int semid )
{
    struct sembuf spos;
    spos.sem_num = 0;
    spos.sem_op  = -1;
    spos.sem_flg = 0;
    if ( semop( semid, &spos, 1 ) == -1 )
        return false;
    return true;
}

bool V( int semid )
{
    struct sembuf spos;
    spos.sem_num = 0;
    spos.sem_op  = 1;
    spos.sem_flg = 0;
    if ( semop( semid, &spos, 1 ) == -1 )
        return false;
    return true;
}

int main (void)
{
    const int n = 10;
    int maxLoop[7];
    COUNT i;
    pid_t pid;

    int p12 = createSemaphore();
    int p13 = createSemaphore();
    int p24 = createSemaphore();
    int p25 = createSemaphore();
    int p35 = createSemaphore();
    int p46 = createSemaphore();
    int p56 = createSemaphore();
    int p6  = createSemaphore();

    srand( time(NULL) );
    for ( i = 1; i < 7 ; i ++ )
        maxLoop[i] = (rand() % n) + 1;
    P(p12);
    P(p13);
    P(p24);
    P(p25);
    P(p35);
    P(p46);
    P(p56);
    P(p6);

    for ( i = 1; i <= 6 ; i ++ )
    {
        if ( (pid = fork() ) < 0 )
        {
            fprintf( stderr, "fork() error!\n\n" );
            return EXIT_FAILURE;
        }
        else if ( pid == 0 )
            break;
    }

    switch ( i )
    {
        case 1:
            for ( COUNT j = 0 ; j < maxLoop[1] ; j ++ )
            {
                puts( "I am process one." );
                usleep( 500000 );
            }
            V(p12);
            V(p13);
            return EXIT_SUCCESS;
        case 2:
            P(p12);
            for ( COUNT j = 0 ; j < maxLoop[2] ; j ++ )
            {
                puts( "I am process two." );
                usleep( 500000 );
            }
            V(p24);
            V(p25);
            return EXIT_SUCCESS;
        case 3:
            P(p13);
            for ( COUNT j = 0 ; j < maxLoop[3] ; j ++ )
            {
                puts( "I am process three." );
                usleep( 500000 );
            }
            V(p35);
            return EXIT_SUCCESS;
        case 4:
            P(p24);
            for ( COUNT j = 0 ; j < maxLoop[4] ; j ++ )
            {
                puts( "I am process four." );
                usleep( 500000 );
            }
            V(p46);
            return EXIT_SUCCESS;
        case 5:
            P(p25);
            P(p35);
            for ( COUNT j = 0 ; j < maxLoop[5] ; j ++ )
            {
                puts( "I am process five." );
                usleep( 500000 );
            }
            V(p56);
            return EXIT_SUCCESS;
        case 6:
            P(p46);
            P(p56);
            for ( COUNT j = 0 ; j < maxLoop[6] ; j ++ )
            {
                puts( "I am process six." );
                usleep( 500000 );
            }
            V(p6);
            return EXIT_SUCCESS;
        default:
            P(p6);
            destroySemaphore( p12 );
            destroySemaphore( p13 );
            destroySemaphore( p24 );
            destroySemaphore( p25 );
            destroySemaphore( p35 );
            destroySemaphore( p46 );
            destroySemaphore( p56 );
            destroySemaphore( p6 );
            puts("All Processes have finished.");
            return EXIT_SUCCESS;
    }


    return EXIT_SUCCESS;
}

叶剑飞Victor 2013-10-06 17:26 发表评论

/*
 * victor.c
 * 
 * Copyright 2012 叶剑飞
 * 
 * Compile command:
 *        gcc victorshell.c -o victorshell -std=gnu99 -pedantic -D_REENTRANT -lpthread -Wall
 * 
 */


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include <stdarg.h>
#include <sys/types.h>
#include <pwd.h>
#include <sys/wait.h>
#include <pthread.h>

#define MAX_LENGTH 256

typedef int COUNT;

typedef struct
{
    pid_t pid;
    char cmdline[MAX_LENGTH];
} PROCESS_STRUCTURE;

void version(void)
{
    puts( "Victor Shell, version 1.0.0-beta" );
    puts( "Copyright (C) 2012 Victor Jianfei Ye" );
    puts("");
}

void arghelp( const char * currentFilename )
{
    version();
    printf ( "Usage:%s [option] \n", currentFilename );
    puts ( "Options:" );
    puts( "\t--version");
    puts( "\t--help");
    puts( "\t-v" );
}

void help(const char * content)
{
    if ( content == NULL )
    {
        version();
        puts ( "exit" );
        puts ( "cd" );
        puts ( "clear" );
        puts ( "pwd" );
        puts ( "echo" );
        puts ( "" );
    }
    else
    {
        if ( !strcmp( content, "exit" ) )
        {
            puts( "exit: exit [n]" );
            puts( "\tExit the shell." );
            puts( "" );
            puts( "\tExits the shell with a status of N.  If N is omitted, the exit status" );
            puts( "\tis that of the last command executed." );
        }
        else if ( !strcmp( content, "cd" ) )
        {
            puts( "cd: cd <directory name>" );
            puts( "\tchange to the directory" );
            puts( "" );
        }
        else if ( !strcmp( content, "clear" ) )
        {
            puts( "clear: clear" );
            puts( "\tclear the terminal screen" );
        }
        else if ( !strcmp( content, "pwd" ) )
        {
            puts( "pwd: pwd" );
            puts( "Print the name of the current working directory." );
        }
        else if ( !strcmp( content, "echo" ) )
        {
            puts( "echo: echo [arg ]" );
            puts( "\tWrite arguments to the standard output." );
            puts( "\tDisplay the ARGs on the standard output followed by a newline." );
            puts( "" );
        }
    }
}

bool exeInternalCmd( const char *cmd )
{
    int argc;
    char argv[MAX_LENGTH][MAX_LENGTH];
    memset( argv, 0, sizeof(argv) );
    argc = sscanf(cmd, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17], argv[18], argv[19], argv[20], argv[21], argv[22], argv[23], argv[24], argv[25], argv[26], argv[27], argv[28], argv[29], argv[30], argv[31], argv[32], argv[33], argv[34] );
    if ( argc <= 0 )
        return true;
    else if ( argc >= 1 )
    {
        if ( argv[0][0] == '#' )
            return true;
        if ( !strcmp( argv[0], "exit" ) )
        {
            puts("exit");
            if ( argc == 1 )
                exit(EXIT_SUCCESS);
            else if ( argc == 2 )
            {
                int exitcode;
                if ( sscanf( argv[1], "%d", &exitcode ) == 1 )
                    exit( exitcode );
                else
                {
                    printf("victorshell: exit: %s: numeric argument required\n", argv[1] );
                    exit(255);
                }
            }
            else
            {
                puts("victorshell: exit: too many arguments");
                exit(EXIT_FAILURE);
            }
        }
        else if ( !strcmp(argv[0], "cd" ) )
        {
            if( argc == 1 || (argc == 2 && !strcmp( argv[1], "~") ) )
            {
                if ( chdir(getenv("HOME")) != 0 )
                    printf( "victorshell: cd: %s: no such file or directory\n", getenv("HOME") );
            }
            else if ( argc == 2 && !strcmp( argv[1] , "-" ) )
            {
                char * oldPwd = getenv("OLDPWD");
                char curPwd[MAX_LENGTH];
                if ( getcwd( curPwd, sizeof(curPwd) ) == NULL )
                    strncpy( curPwd, "", 3 ) ;
                if ( oldPwd == NULL )
                    puts( "victorshell: cd: OLDPWD not set" );
                else
                {
                    if ( chdir(oldPwd) != 0 )
                        printf( "victorshell: cd: %s: no such file or directory\n", oldPwd );
                    else
                    {
                        puts( oldPwd );
                        if ( strcmp( curPwd, "" ) )
                            setenv( "OLDPWD", curPwd, 1 );
                        else
                            unsetenv( "OLDPWD" );
                    }
                }
            }
            else
            {
                char curPwd[MAX_LENGTH];
                if ( getcwd( curPwd, sizeof(curPwd) ) == NULL )
                    strncpy( curPwd, "", 3 ) ;
                if( chdir(argv[1]) != 0 )
                    printf( "victorshell: cd: %s: no such file or directory\n", argv[1] );
                else
                {
                    if ( strcmp( curPwd, "" ) )
                        setenv( "OLDPWD", curPwd, 1 );
                    else
                        unsetenv( "OLDPWD" );
                }
            }
            return true;
        }
        else if ( !strcmp(argv[0], "echo" ) )
        {
            if ( argc > 1 )
            {
                printf( "%s", argv[1] );
                for ( int i = 2; i < argc; i ++ )
                    printf ( " %s", argv[i] );
            }
            puts("");
            return true;
        }
        else if ( !strcmp( argv[0], "pwd" ) )
        {
            char path[MAX_LENGTH];
            if ( getcwd(path, sizeof(path)) == NULL )
                puts("invalid path");
            else
                puts(path);
            return true;
        }
        else if ( !strcmp( argv[0], "clear" ) )
        {
            printf("\033[H\033[2J");
            return true;
        }
        else if ( !strcmp( argv[0], "environ" ) )
        {
            char path[MAX_LENGTH];
            getcwd( path, sizeof(path) );
            printf( "USER=%s\n", getpwuid(getuid())->pw_name );
            printf( "PWD=%s\n", path );
            printf( "HOME=%s\n", getenv("HOME") );
            printf( "PATH=%s\n", getenv("PATH") );
            return true;
        }
        else if ( !strcmp(argv[0], "help" ) )
        {
            if ( argc == 1 )
                help(NULL);
            else
                help(argv[1]);
            return true;
        }
    }
    return false;
}

void * waitBackgroundProcess ( void * args )
{
    int status;
    PROCESS_STRUCTURE processStructure = *(PROCESS_STRUCTURE *)args;
    pid_t pid = processStructure.pid;
    waitpid( pid, &status, 0 );
    if ( WEXITSTATUS(status) == EXIT_FAILURE )
    {
        fprintf( stderr, "victorshell: %s: command not found\n", processStructure.cmdline );
    }
    else
    {
        printf ( "Done\t\t\t%s\n", processStructure.cmdline );
    }
    return NULL;
}

bool exeExternalCmd( const char * cmd )
{
    int argc;
    COUNT i;
    pid_t pid;
    char * argv[MAX_LENGTH];
    int status;
    bool background;
    for ( i = 0 ; i < MAX_LENGTH ; i ++ )
    {
        argv[i] = (char *)malloc( MAX_LENGTH * sizeof(char) );
    }
    argc = sscanf(cmd, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14], argv[15], argv[16], argv[17], argv[18], argv[19], argv[20], argv[21], argv[22], argv[23], argv[24], argv[25], argv[26], argv[27], argv[28], argv[29], argv[30], argv[31], argv[32], argv[33], argv[34] );
    for ( i = argc ; i < MAX_LENGTH ; i ++ )
    {
        free( argv[i] );
        argv[i] = NULL;
    }
    if ( !strcmp( argv[argc-1], "&") ) 
    {
        free( argv[argc-1] );
        argv[argc-1] = NULL;
        background = true;
    }
    else if ( argv[argc-1][strlen(argv[argc-1])-1] == '&' ) 
    {
        argv[argc-1][strlen(argv[argc-1])-1] = '\0';
        background = true;
    }
    else
    {
        background = false;
    }

    if ( (pid = fork() ) < 0 )
    {
        puts ( "fork() failed." );
        return true;
    }
    else if ( pid == 0 )
    {
        if ( execvp( argv[0], argv ) < 0 )
        {
            exit( EXIT_FAILURE );
        }
    }
    if ( background ) 
    {
        pthread_t backgroundWaitingThread;
        PROCESS_STRUCTURE processStructure;
        processStructure.pid = pid;
        strncpy( processStructure.cmdline, argv[0] , MAX_LENGTH ) ;
        pthread_create( &backgroundWaitingThread, NULL, waitBackgroundProcess, (void *)&processStructure );
        return true;
    }
    else
    {
        waitpid( pid, &status, 0 );
        if ( WEXITSTATUS(status) == EXIT_FAILURE )
            return false;
        else
            return true;
    }
}

int main (int argc, char * argv[])
{
    FILE * fp = NULL;
    bool debug = false;
    char cmd[MAX_LENGTH];
    memset( cmd, 0, sizeof(cmd) );
    if ( argc >= 2 )
    {
        if ( !strcmp("-v", argv[1] ) )
            debug = true;
        else if ( !strcmp("--help", argv[1] ) )
        {
            arghelp(argv[0]);
            return EXIT_SUCCESS;
        }
        else if ( !strcmp("--version", argv[1] ) )
        {
            version();
            return EXIT_SUCCESS;
        }
        else
        {
            if ( ( fp = fopen(argv[1] , "r" ) ) == NULL )
            {
                printf( "victorshell: %s: invalid option\n", argv[1] );
                arghelp( argv[0] );
                return EXIT_FAILURE;
            }
        }
    }
    if ( fp == NULL )
        fp = stdin;
    while (true)
    {
        char path[MAX_LENGTH];
        char hostname[MAX_LENGTH];
        if ( fp == stdin )
        {
            gethostname( hostname, sizeof(hostname) );
            getcwd( path, sizeof(path) );
            printf ( "[%s@%s %s]", getpwuid(getuid())->pw_name, hostname, path );
            if ( getuid() == 0 )
                printf ( "# " );
            else
                printf ( "$ " );
            fflush( stdout );
        }
        if ( fgets(cmd, sizeof(cmd)-1, fp ) == NULL )
        {
            if ( fp != stdin )
                fclose( fp );
            return EXIT_SUCCESS;
        }
        cmd[strlen(cmd)-1] = '\0';
        if (debug)
            puts(cmd);
        if ( !exeInternalCmd(cmd) )
        {
            if( !exeExternalCmd(cmd) )
            {
                char argfirst[MAX_LENGTH];
                sscanf( cmd, "%s", argfirst );
                printf( "victorshell: %s: command not found\n", argfirst );
            }
        }
    }
    return EXIT_SUCCESS;
}

叶剑飞Victor 2013-10-06 17:15 发表评论

叶剑飞Victor 2013-10-06 16:55 发表评论