root/branches/OB-DBPF-OPEN-CACHE-REMOVE/src/server/pjmp-machines.sm @ 8770

/* 
 * (C) 2001 Clemson University and The University of Chicago 
 *
 * See COPYING in top-level directory.
 *
 * Changes by Acxiom Corporation to add dirent_count field to attributes
 * Copyright © Acxiom Corporation, 2005.
 */

#include <string.h>
#include <assert.h>

#include "server-config.h"
#include "pvfs2-server.h"
#include "pvfs2-attr.h"
#include "pvfs2-types.h"
#include "pvfs2-types-debug.h"
#include "pvfs2-util.h"
#include "pint-util.h"
#include "pvfs2-internal.h"
#include "pint-cached-config.h"

%%
machine pvfs2_pjmp_get_attr_work_sm
{
    state pjmp_get_attr_work_initialize
    {
        run pjmp_initialize;
        default => pjmp_call_get_attr_work_sm;
    }

    state pjmp_call_get_attr_work_sm
    {
        jump pvfs2_get_attr_work_sm;
        default => pjmp_get_attr_work_execute_terminate;
    }

    state pjmp_get_attr_work_execute_terminate
    {
        run pjmp_execute_terminate;
        default => terminate;
    }
}


machine pvfs2_pjmp_create_immutable_copies_sm
{
    state pjmp_create_immutable_copies_initialize
    {
        run pjmp_initialize;
        default => pjmp_call_create_immutable_copies_sm;
    }

    state pjmp_call_create_immutable_copies_sm
    {
        jump pvfs2_create_immutable_copies_sm;
        default => pjmp_create_immutable_copies_execute_terminate;
    }

    state pjmp_create_immutable_copies_execute_terminate
    {
        run pjmp_execute_terminate;
        default => terminate;
    }
}


machine pvfs2_pjmp_mirror_work_sm
{
    state pjmp_mirror_work_initialize
    {
        run pjmp_initialize;
        default => pjmp_call_mirror_work_sm;
    }

    state pjmp_call_mirror_work_sm
    {
        jump pvfs2_mirror_work_sm;
        default => pjmp_mirror_work_execute_terminate;
    }

    state pjmp_mirror_work_execute_terminate
    {
        run pjmp_execute_terminate;
        default => terminate;
    }
}


machine pvfs2_pjmp_remove_work_sm
{
    state pjmp_remove_work_initialize
    {
        run pjmp_remove_work_schedule_job;
        success => pjmp_call_remove_work_sm;
        default => pjmp_remove_work_execute_terminate;
    }

    state pjmp_call_remove_work_sm
    {
        jump pvfs2_remove_work_sm;
        default => pjmp_remove_work_release_job;
    }

    state pjmp_remove_work_release_job
    {
        run pjmp_remove_work_release_job;
        default => pjmp_remove_work_execute_terminate;
    }
    state pjmp_remove_work_execute_terminate
    {
        run pjmp_remove_work_execute_terminate;
        default => terminate;
    }
}


machine pvfs2_pjmp_get_attr_with_prelude_sm
{
    state pjmp_initialize
    {
        run pjmp_initialize;
        default => pjmp_call_get_attr_with_prelude;
    }

    state pjmp_call_get_attr_with_prelude
    {
        jump pvfs2_get_attr_with_prelude_sm;
        default => pjmp_execute_terminate;
    }

    state pjmp_execute_terminate
    {
        run pjmp_execute_terminate;
        default => terminate;
    } 
}


machine pvfs2_pjmp_call_msgpairarray_sm
{
   state call_msgpairarray
    {
        run call_msgpairarray;
        success => transfer_msgpair;
        default => cleanup_msgpairarray;
    }

   state transfer_msgpair
    {
         jump pvfs2_msgpairarray_sm;
         default => cleanup_msgpairarray;
    }

   state cleanup_msgpairarray
    {
        run cleanup_msgpairarray;
        default => terminate;
    }
} /*end state machine pvfs2_pjmp_call_msgpairarray_sm*/
%%

static PINT_sm_action pjmp_initialize( struct PINT_smcb *smcb
                                     , job_status_s *js_p)
{
    js_p->error_code = 0;
    return SM_ACTION_COMPLETE;
}

static PINT_sm_action pjmp_execute_terminate( struct PINT_smcb *smcb
                                            , job_status_s *js_p)
{
    return SM_ACTION_TERMINATE;
}

/****************************************************************************/
/* Actions for pvfs2_pjmp_call_msgpairarray_sm                              */
/****************************************************************************/

/*We use a separate nested state machine to call msgpairarray because */
/*msgpairarray.sm is setup to work only with a "jump".  When "pjmp"   */
/*is used, the frame stack gets corrupted.                            */
static PINT_sm_action call_msgpairarray (struct PINT_smcb *smcb
                                        ,job_status_s *js_p)
{   
   gossip_debug(GOSSIP_SERVER_DEBUG,"Executing pvfs2_pjmp_call_msgpairarray_sm:"
                                    "call_msgpairarray for operation (%s)\n"
                                   ,PINT_map_server_op_to_string(smcb->op));
   gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing pvfs2_pjmp_call_msgpairarray_sm:"
                                    "call_msgpairarray for operation (%s)\n"
                                   ,PINT_map_server_op_to_string(smcb->op));
   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tframe count is %d.\n",smcb->frame_count);
   gossip_debug(GOSSIP_MIRROR_DEBUG,"\t base frame is %d.\n",smcb->base_frame);
   gossip_debug(GOSSIP_MIRROR_DEBUG,"\t op nbr is #%d.\n",smcb->op);

   struct PINT_server_op *s_op = PINT_sm_frame(smcb,PINT_FRAME_CURRENT);
   PINT_sm_msgarray_op *msgarray = &(s_op->msgarray_op);

   gossip_debug(GOSSIP_MIRROR_DEBUG,"\ts_op:%p\n",s_op);

   js_p->error_code = 0;

   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tmsgarray->msgpair.req.op:%d\n"
                                    ,msgarray->msgpair.req.op );

   PINT_sm_push_frame(smcb,0,msgarray);
   
   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tAFTER PUSH:smcb->base_frame:%d"
                                    "\tframe_count:%d\n"
                                   ,smcb->base_frame,smcb->frame_count);

   return SM_ACTION_COMPLETE;
}/*end action call_msgpairarray*/

static PINT_sm_action cleanup_msgpairarray (struct PINT_smcb *smcb
                                           ,job_status_s *js_p)
{   
   gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing pvfs2_pjmp_call_msgpairarray_sm:cleanup_msgpairarray"
                                    "....\n");
   struct PINT_server_op *s_op = PINT_sm_frame(smcb,PINT_FRAME_CURRENT);
   PINT_sm_msgarray_op *msgarray = &(s_op->msgarray_op);

   gossip_debug(GOSSIP_MIRROR_DEBUG,"\ts_op:%p\n",s_op);

   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tjs_p->error_code:%d\n"
                                   ,js_p->error_code);
   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tBEFORE POP:smcb->frame_base:%d"
                                    "\tframe_count:%d\n"
                                   ,smcb->base_frame,smcb->frame_count);


   gossip_debug(GOSSIP_MIRROR_DEBUG,"\tmsgarray->msgpair.req.op:%d\n"
                                    ,msgarray->msgpair.req.op );

   gossip_debug(GOSSIP_MIRROR_DEBUG,"\ts_op->resp.status:%d\n"
                                   ,s_op->resp.status);

   return SM_ACTION_TERMINATE;
}/*end action cleanup_msgpairarray*/

static PINT_sm_action pjmp_remove_work_schedule_job(struct PINT_smcb *smcb, job_status_s *js_p)
{
   int ret;
   struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);

   ret = PINT_server_req_get_object_ref(s_op->req
                                       ,&s_op->target_fs_id
                                       ,&s_op->target_handle);
   s_op->access_type = PINT_server_req_get_access_type(s_op->req);
   s_op->sched_policy = PINT_server_req_get_sched_policy(s_op->req);

   gossip_err("pjmp_remove_work_schedule_job: s_op->target_fs_id:%llu   s_op->target_handle:%llu\n"
              ,llu(s_op->target_fs_id)
              ,llu(s_op->target_handle));

   js_p->error_code = 0;
   ret = job_req_sched_post( s_op->op
                            ,s_op->target_fs_id
                            ,s_op->target_handle
                            ,s_op->access_type
                            ,s_op->sched_policy
                            ,smcb
                            ,0
                            ,js_p
                            ,&(s_op->scheduled_id)
                            ,server_job_context);
   return ret;
}/*end pjmp_remove_work_schedule_job*/


static PINT_sm_action pjmp_remove_work_release_job(struct PINT_smcb *smcb, job_status_s *js_p)
{
   int ret = -1;
   job_id_t tmp_id;
   struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);

   /* save the error-code returned from the previous step */
   s_op->u.remove.saved_error_code = js_p->error_code;

   ret = job_req_sched_release( s_op->scheduled_id
                               ,smcb
                               ,0
                               ,js_p
                               ,&tmp_id
                               ,server_job_context);
 
   return ret;  
}/*end pjmp_remove_work_release_job*/

static PINT_sm_action pjmp_remove_work_execute_terminate(struct PINT_smcb *smcb, job_status_s *js_p)
{
   struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);

   js_p->error_code = s_op->u.remove.saved_error_code;

   return SM_ACTION_TERMINATE;
}/*end pjmp_remove_execute_terminate */


/*
 * Local variables:
 *  mode: c
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ft=c ts=8 sts=4 sw=4 expandtab
 */