Changeset f16c059 in rtems


Ignore:
Timestamp:
Jan 17, 2011, 10:12:48 PM (9 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.11, master
Children:
a0cd0829
Parents:
25edf9cd
Message:

2011-01-17 Alin Rus <alin.codejunkie@…>

  • posix/src/aio_cancel.c: Fixed ending of if braces.

2011-01-17 Alin Rus <alin.codejunkie@…>

  • posix/src/aio_misc.c: Add debug information. Fixed idle_threads/ active_threads issues. Fixed infinite loop in rtems_aio_handle().
Location:
cpukit
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r25edf9cd rf16c059  
     12011-01-17      Alin Rus <alin.codejunkie@gmail.com>
     2
     3        * posix/src/aio_cancel.c: Fixed ending of if braces.
     4
     52011-01-17      Alin Rus <alin.codejunkie@gmail.com>
     6
     7        * posix/src/aio_misc.c: Add debug information. Fixed idle_threads/
     8        active_threads issues. Fixed infinite loop in rtems_aio_handle().
     9
    1102011-01-08      Alin Rus <alin.codejunkie@gmail.com>
    2        
     11
    312        * posix/src/aio_misc.c: Fix rtems_aio_remove_req did not iterate
    413        over chain.
  • cpukit/libmisc/shell/main_rtc.c

    r25edf9cd rf16c059  
    126126
    127127    if (argc > 3) {
    128       rv = sscanf( argv [3], "%" PRIu32, v);
     128      rv = sscanf( argv [3], "%5" PRIu32, v);
    129129
    130130      if (rv == 1) {
  • cpukit/libmisc/shell/shell_script.c

    r25edf9cd rf16c059  
    4747static int findOnPATH(
    4848  const char *userScriptName,
    49   char       *scriptFile
     49  char       *scriptFile,
     50  size_t      scriptFileLength
    5051)
    5152{
     
    5758   */
    5859  if ( userScriptName[0] == '/' ) {
    59     strcpy( scriptFile, userScriptName );
     60    strncpy( scriptFile, userScriptName, PATH_MAX );
    6061  } else {
    6162    /*
     
    6768    /* XXX should use strncat but what is the limit? */
    6869    getcwd( scriptFile, PATH_MAX );
    69     strcat( scriptFile, "/" );
    70     strcat(
     70    strncat( scriptFile, "/", PATH_MAX );
     71    strncat(
    7172      scriptFile,
    7273      ( (userScriptName[0] == '.' && userScriptName[1] == '/') ?
    73          &userScriptName[2] : userScriptName)
     74         &userScriptName[2] : userScriptName),
     75      PATH_MAX
    7476    );
    7577  }
     
    188190   *        seems to be the most expedient thing.
    189191   */
    190   sc = findOnPATH( argv[getopt_reent.optind], scriptFile );
     192  sc = findOnPATH( argv[getopt_reent.optind], scriptFile, PATH_MAX );
    191193  if ( sc ) {
    192194    fprintf( stderr, "%s: command not found\n", argv[0] );
     
    259261   *  Find argv[0] on the path
    260262   */
    261   sc = findOnPATH( argv[0], scriptFile );
     263  sc = findOnPATH( argv[0], scriptFile, PATH_MAX );
    262264  if ( sc ) {
    263265    fprintf( stderr, "%s: command not found\n", argv[0] );
  • cpukit/posix/src/aio_cancel.c

    r25edf9cd rf16c059  
    114114        return AIO_ALLDONE;
    115115      }
    116 
     116    } 
    117117      AIO_printf ("Request on [WQ]\n");
    118118     
     
    122122      pthread_mutex_unlock (&aio_request_queue.mutex);
    123123      return result;
    124     }
    125124  }
    126125  return AIO_ALLDONE;
  • cpukit/posix/src/aio_misc.c

    r25edf9cd rf16c059  
    11/*
    2  * Copyright 2010, Alin Rus <alin.codejunkie@gmail.com>
     2 * Copyright 2010-2011, Alin Rus <alin.codejunkie@gmail.com>
    33 *
    44 * The license and distribution terms for this file may be
     
    1414#include <time.h>
    1515#include <rtems/posix/aio_misc.h>
     16#include <errno.h>
    1617
    1718static void *rtems_aio_handle (void *arg);
     
    123124  return r_chain;
    124125}
     126
     127/*
     128 *  rtems_aio_move_to_work
     129 *
     130 * Move chain of requests from IQ to WQ
     131 *
     132 *  Input parameters:
     133 *        r_chain      - chain of requests
     134 *
     135 *  Output paramteres:
     136 *        NONE
     137 */
     138
     139void
     140rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
     141{
     142  rtems_aio_request_chain *temp;
     143  rtems_chain_node *node;
     144 
     145  node = rtems_chain_first (&aio_request_queue.work_req);
     146  temp = (rtems_aio_request_chain *) node;
     147
     148  while (temp->fildes < r_chain->fildes &&
     149         !rtems_chain_is_tail (&aio_request_queue.work_req, node)) {
     150    node = rtems_chain_next (node);
     151    temp = (rtems_aio_request_chain *) node;
     152  }
     153 
     154  rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
     155}
     156 
    125157
    126158/*
     
    292324        pthread_mutex_init (&r_chain->mutex, NULL);
    293325        pthread_cond_init (&r_chain->cond, NULL);
    294        
     326           
    295327        AIO_printf ("New thread \n");
    296328        result = pthread_create (&thid, &aio_request_queue.attr,
     
    338370          pthread_mutex_init (&r_chain->mutex, NULL);
    339371          pthread_cond_init (&r_chain->cond, NULL);
    340           pthread_cond_signal (&aio_request_queue.new_req);
    341           ++aio_request_queue.idle_threads;
    342372        } else
    343373          /* just insert the request in the existing fd chain */
    344374          rtems_aio_insert_prio (&r_chain->perfd, req);
     375        if (aio_request_queue.idle_threads > 0)
     376          pthread_cond_signal (&aio_request_queue.new_req);
    345377      }
    346378    }
     
    386418      return NULL;
    387419   
    388     chain = &r_chain->perfd;
     420    chain = &r_chain->perfd;   
    389421
    390422    /* If the locked chain is not empty, take the first
     
    394426    if (!rtems_chain_is_empty (chain)) {
    395427
     428      AIO_printf ("Get new request from not empty chain\n");   
    396429      node = rtems_chain_first (chain);
    397430      req = (rtems_aio_request *) node;
     
    409442      switch (req->aiocbp->aio_lio_opcode) {
    410443      case LIO_READ:
     444        AIO_printf ("read\n");
    411445        result = pread (req->aiocbp->aio_fildes,
    412446                        (void *) req->aiocbp->aio_buf,
     
    415449
    416450      case LIO_WRITE:
     451        AIO_printf ("write\n");
    417452        result = pwrite (req->aiocbp->aio_fildes,
    418453                         (void *) req->aiocbp->aio_buf,
     
    421456       
    422457      case LIO_SYNC:
     458        AIO_printf ("sync\n");
    423459        result = fsync (req->aiocbp->aio_fildes);
    424460        break;
     
    446482         wait for a signal on chain, this will unlock the queue.
    447483         The fd chain is already unlocked */
    448      
     484
    449485      struct timespec timeout;
     486     
     487      AIO_printf ("Chain is empty [WQ], wait for work\n");
    450488     
    451489      pthread_mutex_unlock (&r_chain->mutex);
    452490      pthread_mutex_lock (&aio_request_queue.mutex);
     491     
    453492      if (rtems_chain_is_empty (chain))
    454493        {
     
    457496          timeout.tv_nsec = 0;
    458497          result = pthread_cond_timedwait (&r_chain->cond,
    459                                            &aio_request_queue.mutex, &timeout);
    460          
     498                                           &aio_request_queue.mutex,
     499                                           &timeout);
     500
    461501          /* If no requests were added to the chain we delete the fd chain from
    462502             the queue and start working with idle fd chains */
     
    470510               signal. The thread now becomes idle. */
    471511            if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
     512              AIO_printf ("Chain is empty [IQ], wait for work\n");           
     513
    472514              ++aio_request_queue.idle_threads;
     515              --aio_request_queue.active_threads;
    473516              clock_gettime (CLOCK_REALTIME, &timeout);
    474517              timeout.tv_sec += 3;
    475518              timeout.tv_nsec = 0;
     519
    476520              result = pthread_cond_timedwait (&aio_request_queue.new_req,
    477521                                               &aio_request_queue.mutex,
     
    481525                 then this thread is finished */
    482526              if (result == ETIMEDOUT) {
     527                AIO_printf ("Etimeout\n");
     528                --aio_request_queue.idle_threads;
    483529                pthread_mutex_unlock (&aio_request_queue.mutex);
    484530                return NULL;
    485531              }
    486              
    487               /* Otherwise move this chain to the working chain and
    488                  start the loop all over again */
    489               --aio_request_queue.idle_threads;
    490               node = rtems_chain_first (&aio_request_queue.idle_req);
    491               rtems_chain_extract (node);
    492               r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
    493                                              ((rtems_aio_request_chain *)node)->fildes,
    494                                              1);
    495               r_chain->new_fd = 0;
    496               pthread_mutex_init (&r_chain->mutex, NULL);
    497               pthread_cond_init (&r_chain->cond, NULL);
    498              
    499               r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
    500532            }
    501             else
    502               /* If there was a request added in the initial fd chain then release
    503                  the mutex and process it */
    504               pthread_mutex_unlock (&aio_request_queue.mutex);
     533            /* Otherwise move this chain to the working chain and
     534               start the loop all over again */
     535            AIO_printf ("Work on idle\n");
     536            --aio_request_queue.idle_threads;
     537            ++aio_request_queue.active_threads;
     538
     539            node = rtems_chain_first (&aio_request_queue.idle_req);
     540            rtems_chain_extract (node);
     541
     542            r_chain = (rtems_aio_request_chain *) node;
     543            rtems_aio_move_to_work (r_chain);
     544           
    505545          }
    506546        }
     547      /* If there was a request added in the initial fd chain then release
     548         the mutex and process it */
     549      pthread_mutex_unlock (&aio_request_queue.mutex);
     550     
    507551    }
    508552  }
    509553 
    510 
    511554  AIO_printf ("Thread finished\n");
    512555  return NULL;
Note: See TracChangeset for help on using the changeset viewer.