lmcore.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 1,370 行 · 第 1/3 页

    /* Increment the timestamp for every file with an outstanding write
       lock for this user */
    for (ft = lmcb->filetab, ii = 0; ii < lmcb->numfiles; ii++, ft++) {
        if (is_bit_set(ft->f_lock, user)) {
            switch (ft->f_lockstat) {
                case 'w':
                case 'W':
                case 'x':
                case 'X':
                    ft->f_timestamp++;
                    break;

                default:
                    break;
            }
        }
    }

    fileid_del(lmcb->fidtab, ut->u_logfile);
    ut->u_logfile = -1;
    reply_user(lmcb, user, NULL, 0, L_OKAY);
}

static void l_settime(
    LMCB       *lmcb,
    int         user,
    LM_SETTIME *msg)
{
    USERTAB *ut = &lmcb->usertab[user];

    DEBUG2(DB_TEXT("l_settime(user = %d)\n"), user)
    lmcb->usertab[user].u_timeout = msg->queue_timeout;
    psp_lmcFree(msg);
    reply_user(lmcb, user, NULL, 0, L_OKAY);
}

static void l_recdone(
    LMCB  *lmcb,
    int    user,
    void  *msg)
{
    short    ii;
    short    excl;
    short    dead_id;
    USERTAB *ut = &lmcb->usertab[user];
    TAFTAB  *tt = &lmcb->taftab[ut->u_taf];
    FILETAB *ft;

    DEBUG2(DB_TEXT("l_recdone(user = %d)\n"), user)

    if (tt->t_status != REC_EXTERNAL) {
        /* This user has just completed recovering the files of a dead user.
           Now the files held by the dead user may be freed and closed. */
        if ((dead_id = ut->u_recuser) != -1) {
            ft = lmcb->filetab;
            for (excl = 0, ii = 0; ii < lmcb->numfiles; ii++, ft++) {
                if (!is_bit_set(ut->u_open, ii))
                    continue;

                if (ft->f_lockstat == 'x')
                    excl = 1;
                else {
                    if (ft->f_lockstat != 'f')
                        freelock(lmcb, dead_id, ii);

                    close_file(lmcb, dead_id, ii);
                }
            }

            /* change this entry to a normal status */
            ut->u_status = U_LIVE;
            ut->u_recuser = -1;
            ut->u_logfile = -1;
        }

        /* close out the dead user entry */
        if (dead_id != -1 && dead_id != user) {
            if (excl) {
                lmcb->usertab[dead_id].u_status = U_HOLDING_X;
                lmcb->usertab[dead_id].u_logfile = -1;
            }
            else
                close_user(lmcb, dead_id);
        }
    }

    tt->t_status = REC_OKAY;
    reply_user(lmcb, user, NULL, 0, L_OKAY);
}

static void l_recfail(
    LMCB  *lmcb,
    int    user,
    void  *msg)
{
    USERTAB *ut = &lmcb->usertab[user];

    DEBUG2(DB_TEXT("l_recfail(user = %d)\n"), user)

    lmcb->taftab[ut->u_taf].t_status = REC_NEEDED;
    reply_user(lmcb, user, NULL, 0, L_OKAY);
}

static void l_options(
    LMCB       *lmcb,
    int         user,
    LM_OPTIONS *msg)
{
}

static void l_verifyuser(
    LMCB  *lmcb,
    int    user,
    void  *msg)
{
    DEBUG2(DB_TEXT("l_verifyuser(user = %d)\n"), user)

    reply_non_user(lmcb, user, NULL, 0, L_OKAY);
}

static void l_status(
    LMCB      *lmcb,
    int        user,
    LM_STATUS *msg)
{
    DEBUG3(DB_TEXT("l_status(user = %d, type = %d)\n"), user,
            msg->type_of_status)

    switch (msg->type_of_status) {
        case ST_GENSTAT:
            l_status_genstat(lmcb, user);
            break;

        case ST_TABLES:
            l_status_tables(lmcb, user, &msg->tabsize);
            break;

        case ST_USERINFO:
            l_status_userinfo(lmcb, user, &msg->tabsize, msg->number);
            break;

        case ST_FILEINFO:
            l_status_fileinfo(lmcb, user, &msg->tabsize, msg->number);
            break;

        case ST_USERSTAT:
            l_status_userstat(lmcb, user, msg->username);
            break;

        case ST_TAFTAB:
            l_status_taftab(lmcb, user, &msg->tabsize);
            break;

        default:
            reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
            break;
    }

    psp_lmcFree(msg);
}

static void l_status_genstat(
    LMCB *lmcb,
    int   user)
{
    LR_STATUS *msg;

    msg = psp_lmcAlloc(sizeof(LR_STATUS));
    if (msg == NULL) {
        reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
        return;
    }
    
    msg->s_tabsize.lm_numusers = lmcb->numusers;
    msg->s_tabsize.lm_numfiles = lmcb->numfiles;
    msg->s_tabsize.lm_maxusers = lmcb->maxusers;
    msg->s_tabsize.lm_maxfiles = lmcb->maxfiles;
    msg->s_tabsize.lm_maxqueue = lmcb->maxqueues;
    msg->s_tabsize.lm_maxtafs  = lmcb->maxusers;
    msg->s_tabsize.lm_numtafs  = lmcb->numtafs;

    reply_non_user(lmcb, user, msg, sizeof(LR_STATUS), L_OKAY);
}

static void l_status_tables(
    LMCB    *lmcb,
    int      user,
    TABSIZE *tabsize)
{
    short       ii;
    short       maxusers;
    long        curr;
    size_t      size;
    LR_TABLES  *msg;
    LR_USERTAB *users;
    LR_FILETAB *files;
    USERTAB    *ut;
    FILETAB    *ft;

    size = sizeof(LR_TABLES) + tabsize->lm_numusers * sizeof(LR_USERTAB) +
            tabsize->lm_numfiles * sizeof(LR_FILETAB) + tabsize->lm_maxqueue *
            sizeof(QUEUETAB);

    if ((msg = psp_lmcAlloc(size)) == NULL) {
        reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
        return;
    }

    memset(msg, 0, size);
    msg->t_msgs_received  = lmcb->requests;
    msg->t_msgs_sent      = lmcb->replys;
    msg->t_locks_granted  = lmcb->locks_granted;
    msg->t_locks_rejected = lmcb->locks_rejected;
    msg->t_locks_timedout = lmcb->locks_timedout;
    msg->t_locks_freed    = lmcb->locks_freed;

    maxusers = lmcb->maxusers;

    curr = psp_timeMilliSecs();
    users = (LR_USERTAB *) (msg + 1);
    ut = lmcb->usertab;
    for (ii = 0; ii < tabsize->lm_numusers; ii++, users++) {
        if (ii < lmcb->numusers) {
            if (ut->u_timer)
                users->ut_timer    = (curr - ut->u_timer) / 1000;
            else
                users->ut_timer    = 0;

            users->ut_pending = ut->u_pending;
            users->ut_status  = ut->u_status;
            users->ut_recover = ut->u_recuser;
            vtstrcpy(users->ut_name, ut->u_name);
            vtstrcpy(users->ut_logfile, get_filename(lmcb, ut->u_logfile, 0));
            ut++;
        }
        else {
            users->ut_status  = U_EMPTY;
            users->ut_recover = -1;
            vtstrcpy(users->ut_name, DB_TEXT("empty"));
        }
    }

    files = (LR_FILETAB *) users;
    ft = lmcb->filetab;
    for (ii = 0; ii < tabsize->lm_numfiles; ii++, files++) {
        if (ii < lmcb->numfiles) {
            files->ft_lockstat       = ft->f_lockstat;
            files->ft_numlocks       = count_bits(ft->f_lock, maxusers);
            files->ft_user_with_lock = first_bit_set(ft->f_lock, maxusers);
            files->ft_queue_entry    = ft->f_queue;
            vtstrcpy(files->ft_name, get_filename(lmcb, ft->f_index, 0));
            ft++;
        }
        else {
            files->ft_lockstat       = DB_TEXT('f');
            files->ft_queue_entry    = -1;
            vtstrcpy(files->ft_name, DB_TEXT("empty"));
        }
    }

    if (tabsize->lm_maxqueue)
        memcpy(files, lmcb->queuetab, sizeof(QUEUETAB) * tabsize->lm_maxqueue);

    reply_non_user(lmcb, user, msg, size, L_OKAY);
}

static void l_status_userinfo(
    LMCB    *lmcb,
    int      user,
    TABSIZE *tabsize,
    int      user_no)
{
    short        ii;
    long         curr = psp_timeMilliSecs();
    size_t       size;
    DB_BYTE     *bm;
    LR_FILEINFO *files;
    LR_USERINFO *msg;
    USERTAB     *ut = &lmcb->usertab[user_no];
    FILETAB     *ft;

    size = sizeof(LR_USERINFO) + lmcb->filebmbytes * 3 + tabsize->lm_numfiles *
            sizeof(LR_FILEINFO) + tabsize->lm_maxqueue * sizeof(QUEUETAB);
    if ((msg = psp_lmcAlloc(size)) == NULL) {
        reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
        return;
    }

    memset(msg, 0, size);
    vtstrcpy(msg->ui_name, ut->u_name);
    msg->ui_pending    = ut->u_pending;
    msg->ui_timeout    = ut->u_timeout;
    msg->ui_status     = ut->u_status;
    msg->ui_recovering = ut->u_recuser;
    if (ut->u_timer)
        msg->ui_timer = (curr - ut->u_timer) / 1000;
    else
        msg->ui_timer = 0;

    if (ut->u_taf != -1) {
        vtstrcpy(msg->ui_taffile, get_filename(lmcb,
                lmcb->taftab[ut->u_taf].t_index, 1));
    }

    vtstrcpy(msg->ui_logfile, get_filename(lmcb, ut->u_logfile, 1));
    (*lmcb->info)(ut->u_conn, msg->ui_netinfo1, msg->ui_netinfo2,
            msg->ui_netinfo3);

    bm = (DB_BYTE *) (msg + 1);
    memcpy(bm, ut->u_open, lmcb->filebmbytes * 3);

    files = (LR_FILEINFO *) (bm + 3 * lmcb->filebmbytes);
    ft = lmcb->filetab;
    for (ii = 0; ii < tabsize->lm_numfiles; ii++, files++) { 
        if (ii < lmcb->numfiles) {
            vtstrcpy(files->fi_name, get_filename(lmcb, ft->f_index, 0));
            files->fi_lockstat = ft->f_lockstat;
            files->fi_queue    = ft->f_queue;
            ft++;
        }
        else
            vtstrcpy(files->fi_name, DB_TEXT("empty"));
    }

    if (tabsize->lm_maxqueue)
        memcpy(files, lmcb->queuetab, sizeof(QUEUETAB) * tabsize->lm_maxqueue);

    reply_non_user(lmcb, user, msg, size, L_OKAY);
}

static void l_status_fileinfo(
    LMCB    *lmcb,
    int      user,
    TABSIZE *tabsize,
    int      file_no)
{
    short        ii;
    size_t       size;
    DB_BYTE     *bm;
    DB_TCHAR    *users;
    LR_FILEINFO *msg;
    FILETAB     *ft = &lmcb->filetab[file_no];
    USERTAB     *ut;

    size = sizeof(LR_FILEINFO) + lmcb->userbmbytes * 2 + tabsize->lm_numusers *
            16 + tabsize->lm_maxqueue * sizeof(QUEUETAB);
    if ((msg = psp_lmcAlloc(size)) == NULL) {
        reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
        return;
    }

    vtstrcpy(msg->fi_name, get_filename(lmcb, ft->f_index, 1));
    msg->fi_lockstat = ft->f_lockstat;
    msg->fi_queue    = ft->f_queue;

    bm = (DB_BYTE *) (msg + 1);
    memcpy(bm, ft->f_open, lmcb->userbmbytes * 2);

    users = (DB_TCHAR *) (bm + 2 * lmcb->userbmbytes);
    ut = lmcb->usertab;
    for (ii = 0; ii < tabsize->lm_numusers; ii++, users += 16) {
        if (ii < lmcb->numusers)
            vtstrncpy(users, (ut++)->u_name, 16);
        else
            vtstrcpy(users, DB_TEXT("empty"));
    }

    if (tabsize->lm_maxqueue)
        memcpy(users, lmcb->queuetab, sizeof(QUEUETAB) * tabsize->lm_maxqueue);

    reply_non_user(lmcb, user, msg, size, L_OKAY);
}

static void l_status_userstat(
    LMCB     *lmcb,
    int       user,
    DB_TCHAR *name)
{
    short    ii;
    short   *msg;
    USERTAB *ut;

    if ((msg = psp_lmcAlloc(sizeof(short))) == NULL) {
        reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
        return;
    }

    for (ut = lmcb->usertab, ii = 0; ii < lmcb->numusers; ii++, ut++) {
        if (!vtstrcmp(ut->u_name, name)) {
            *msg = ut->u_status;
            break;
        }
    }


    if (ii == lmcb->numusers)
        *msg = U_EMPTY;

    reply_non_user(lmcb, user, msg, sizeof(short), L_OKAY);
}

static void l_status_taftab(
    LMCB    *lmcb,
    int      user,
    TABSIZE *tabsize)
{
    short      ii;
    size_t     size;
    LR_TAFTAB *msg;
    LR_TAFTAB *tafs;
    TAFTAB    *tt;

    size = sizeof(LR_TAFTAB) * tabsize->lm_numtafs;
    if ((msg = psp_lmcAlloc(size)) == NULL) {
        reply_non_user(lmcb, user, NULL, 0, L_UNAVAIL);
        return;
    }

    tt = lmcb->taftab;
    for (tafs = msg, ii = 0; ii < tabsize->lm_numtafs; ii++, tafs++) {
        if (ii < lmcb->numtafs) {
            vtstrcpy(tafs->tt_name, get_filename(lmcb, tt->t_index, 1));
            tafs->tt_status  = tt->t_status;
            tafs->tt_recuser = tt->t_recuser;
            tafs->tt_nusers  = tt->t_nusers;
            tt++;
        }
        else {
            vtstrcpy(tafs->tt_name, DB_TEXT("empty"));
            tafs->tt_status  = U_EMPTY;
            tafs->tt_recuser = -1;
            tafs->tt_nusers  = 0;
        }
    }

    reply_non_user(lmcb, user, msg, size, L_OKAY);
}

static DB_TCHAR *get_filename(
    LMCB *lmcb,
    int   fileid,
    short with_path)
{
    DB_TCHAR *s1;
    DB_TCHAR *s2;

    if (fileid == -1)
        return DB_TEXT("");

    s1 = fileid_get(lmcb->fidtab, fileid);
    if (with_path || (s2 = vtstrrchr(s1, DIRCHAR)) == NULL)
        return s1;

    return s2 + 1;
}