jk_shm.c

Tomcat 4.1与WebServer集成组件的源代码包.

#else

static int JK_METHOD jk2_shm_destroy(jk_env_t *env, jk_shm_t *shm)
{
    return JK_OK;
}


static int jk2_shm_create(jk_env_t *env, jk_shm_t *shm)
{
    return JK_ERR;
}

#endif


/* Create or reinit an existing scoreboard. The MPM can control whether
 * the scoreboard is shared across multiple processes or not
 */
static int JK_METHOD jk2_shm_init(struct jk_env *env, jk_shm_t *shm) {
    int rv=JK_OK;
    
    shm->privateData=NULL;

    if( shm->fname==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, "shm.init(): No file\n");
        return JK_ERR;
    }

    /* make sure it's an absolute pathname */
    /*  fname = ap_server_root_relative(pconf, ap_scoreboard_fname); */

    if( shm->size == 0  ) {
        shm->size = shm->slotSize * shm->slotMaxCount;
    }

    if( shm->mbean->debug > 0 ) {
        env->l->jkLog(env, env->l, JK_LOG_DEBUG, "shm.init(): file=%s size=%d\n",
                      shm->fname, shm->size);
    }

    if( shm->size <= 0 ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "shm.create(): No size %s\n", shm->fname);
        return JK_ERR;
    }
    
    rv=jk2_shm_create( env, shm );
    
    if( rv!=JK_OK ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "shm.create(): error mmapping %s\n",
                      shm->fname );
        return rv;
    }

    if( shm->mbean->debug > 0 )
        env->l->jkLog(env, env->l, JK_LOG_DEBUG, 
                      "shm.create(): shm created %#lx\n", shm->head );

    return JK_OK;
}

/** Reset the scoreboard, in case it gets corrupted.
 *  Will remove all slots and set the head in the original state.
 */
static int JK_METHOD jk2_shm_reset(jk_env_t *env, jk_shm_t *shm)
{
    if( shm->head == NULL ) {
        return JK_ERR;
    }
    memset(shm->image, 0, shm->size);

    shm->head->slotSize = shm->slotSize;
    shm->head->slotMaxCount = shm->slotMaxCount;
    shm->head->lastSlot = 1;

    if( shm->mbean->debug > 0 )
        env->l->jkLog(env, env->l, JK_LOG_DEBUG, "shm.init() Reset %s %#lx\n",
                      shm->fname, shm->image);

    return JK_OK;
}

static int jk2_shm_dump(jk_env_t *env, jk_shm_t *shm, char *name)
{
    FILE *f;
    int i;

    env->l->jkLog(env, env->l, JK_LOG_INFO, "shm.dump(): Struct Size=%d slotSize=%d slotCnt=%d head=%#lx\n",
                  shm->size, shm->slotSize, shm->slotMaxCount, shm->head );

    if( shm->head==NULL ) return JK_ERR;

    env->l->jkLog(env, env->l, JK_LOG_INFO, "shm.dump(): shmem  slotSize=%d slotCnt=%d lastSlot=%d ver=%d\n",
                  shm->head->slotSize, shm->head->slotMaxCount, shm->head->lastSlot, shm->head->lbVer );

    for( i=1; i< shm->head->lastSlot; i++ ) {
        jk_shm_slot_t *slot=shm->getSlot( env, shm, i );
        jk_msg_t *msg;

        if( slot==NULL ) continue;
        msg=jk2_msg_ajp_create2( env, env->tmpPool, slot->data, slot->size);

        env->l->jkLog(env, env->l, JK_LOG_INFO, "shm.dump(): slot %d ver=%d size=%d name=%s\n",
                      i, slot->ver, slot->size, slot->name );

        msg->dump( env, msg, "Slot content ");
    }
    
    if( name==NULL ) return JK_ERR;
    
/* 
 * XXX
 * To be checked later, AS400 may need no ccsid 
 * conversions applied if pure binary, for now 
 * I assume stream is EBCDIC and need to be converted 
 * in standard ASCII using codepage 819
 */
#ifdef AS400
    f = fopen(name, "a+, o_ccsid=819");
#else
    f = fopen(name, "a+");
#endif        

    fwrite( shm->head, 1, shm->size, f ); 
    fclose( f );

    env->l->jkLog(env, env->l, JK_LOG_INFO, "shm.dump(): Dumped %d in %s\n",
                  shm->size, name);
    
    return JK_OK;
}


/* pos starts with 1 ( 0 is the head )
 */
jk_shm_slot_t * JK_METHOD jk2_shm_getSlot(struct jk_env *env, struct jk_shm *shm, int pos)
{
    if( pos==0 ) return NULL;
    if( shm->image==NULL ) return NULL;
    if( pos > shm->slotMaxCount ) return NULL;
    /* Pointer aritmethic, I hope it's right */
    return (jk_shm_slot_t *)((long)shm->image + (pos * shm->slotSize));
}

jk_shm_slot_t * JK_METHOD jk2_shm_createSlot(struct jk_env *env, struct jk_shm *shm, 
                                  char *name, int size)
{
    /* For now all slots are equal size
     */
    int slotId;
    int i;
    jk_shm_slot_t *slot;
   
    if (shm->head!=NULL) { 
        for( i=1; i<shm->head->lastSlot; i++ ) {
            slot= shm->getSlot( env, shm, i );
            if( strncmp( slot->name, name, strlen(name) ) == 0 ) {
                return slot;
            }
        }
        /* New slot */
        /* XXX interprocess sync */
        slotId=shm->head->lastSlot++;
    }
    slot=shm->getSlot( env, shm, slotId );

    if( slot==NULL ) return NULL;
    
    env->l->jkLog(env, env->l, JK_LOG_INFO, 
                  "shm.createSlot() Create %d %#lx %#lx\n", slotId, shm->image, slot );
    strncpy(slot->name, name, 64 );
    
    return slot;
}

/** Get an ID that is unique across processes.
 */
int JK_METHOD jk2_shm_getId(struct jk_env *env, struct jk_shm *shm)
{

    return 0;
}



static int JK_METHOD jk2_shm_setAttribute( jk_env_t *env, jk_bean_t *mbean, char *name, void *valueP ) {
    jk_shm_t *shm=(jk_shm_t *)mbean->object;
    char *value=(char *)valueP;
    
    if( strcmp( "file", name ) == 0 ) {
	shm->fname=value;
    } else if( strcmp( "size", name ) == 0 ) {
	shm->size=atoi(value);
    } else {
	return JK_ERR;
    }
    return JK_OK;   

}

/** Copy a chunk of data into a named slot
 */
static int jk2_shm_writeSlot( jk_env_t *env, jk_shm_t *shm,
                              char *instanceName, char *buf, int len )
{
    jk_shm_slot_t *slot;
    
    env->l->jkLog(env, env->l, JK_LOG_INFO, 
                  "shm.writeSlot() %s %d\n", instanceName, len );
    if( len > shm->slotSize ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "shm.writeSlot() Packet too large %d %d\n",
                      shm->slotSize, len );
        return JK_ERR;
    }
    if( shm->head == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "shm.writeSlot() No head - shm was not initalized\n");
        return JK_ERR;
    }
    slot=shm->createSlot( env, shm, instanceName, 0 );
    
    /*  Copy the body in the slot */
    memcpy( slot->data, buf, len );
    slot->size=len;
    slot->ver++;
    /* Update the head lb version number - that would triger
       reconf on the next request */
    shm->head->lbVer++;

    return JK_OK;
}

/* ==================== Dispatch messages from java ==================== */
    
/** Called by java. Will call the right shm method.
 */
static int JK_METHOD jk2_shm_invoke(jk_env_t *env, jk_bean_t *bean, jk_endpoint_t *ep, int code,
                                    jk_msg_t *msg, int raw)
{
    jk_shm_t *shm=(jk_shm_t *)bean->object;

    if( shm->mbean->debug > 0 )
        env->l->jkLog(env, env->l, JK_LOG_DEBUG, 
                      "shm.%d() \n", code);
    
    switch( code ) {
    case SHM_WRITE_SLOT: {
        char *instanceName=msg->getString( env, msg );
        char *buf=msg->buf;
        int len=msg->len;

        return jk2_shm_writeSlot( env, shm, instanceName, buf, len );
    }
    case SHM_RESET: {
        jk2_shm_reset( env, shm );

        return JK_OK;
    }
    case SHM_DUMP: {
        char *name=msg->getString( env, msg );

        jk2_shm_dump( env, shm, name );
        return JK_OK;
    }
    }/* switch */
    return JK_ERR;
}

int JK_METHOD jk2_shm_factory( jk_env_t *env ,jk_pool_t *pool,
                               jk_bean_t *result,
                               const char *type, const char *name)
{
    jk_shm_t *shm;

    shm=(jk_shm_t *)pool->calloc(env, pool, sizeof(jk_shm_t));

    if( shm == NULL )
        return JK_ERR;

    shm->pool=pool;
    shm->privateData=NULL;

    shm->slotSize=DEFAULT_SLOT_SIZE;
    shm->slotMaxCount=DEFAULT_SLOT_COUNT;
    
    result->setAttribute=jk2_shm_setAttribute;
    /* result->getAttribute=jk2_shm_getAttribute; */
    shm->mbean=result; 
    result->object=shm;
    result->invoke=jk2_shm_invoke;
    shm->init=jk2_shm_init;
    shm->destroy=jk2_shm_destroy;
    
    shm->getSlot=jk2_shm_getSlot;
    shm->createSlot=jk2_shm_createSlot;
    shm->reset=jk2_shm_reset;
    
    return JK_OK;
}