Index: Makefile.in =================================================================== RCS file: /projects/cvsroot/pvfs2/Makefile.in,v retrieving revision 1.256 diff -u -a -p -r1.256 Makefile.in --- Makefile.in 15 Jan 2008 22:09:55 -0000 1.256 +++ Makefile.in 9 Feb 2008 21:58:49 -0000 @@ -401,6 +401,8 @@ ADMINSRC_SERVER := LIBSRC := # SERVERSRC is souce code for the pvfs2 server SERVERSRC := +# SERVERBINSRC is source files that don't get added to the server library but must be added to the server binary +SERVERBINSRC := # DOCSRC is source code for documentation DOCSRC := # VISSRC is the source code for visualization tools @@ -493,6 +495,9 @@ ifdef BUILD_SERVER SERVEROBJS := $(patsubst %.c,%-server.o, $(filter %.c,$(SERVERSRC))) # SERVERDEPENDS is a list of dependency files for the server SERVERDEPENDS := $(patsubst %.c,%.d, $(filter %.c,$(SERVERSRC))) + # SERVERBINOBJS is a list of objects not in SERVEROBJS to put into the server + SERVERBINOBJS := $(patsubst %.c,%-server.o, $(filter %.c,$(SERVERBINSRC))) + SERVERBINDEPENDS := $(patsubst %.c,%.d, $(filter %.c,$(SERVERBINSRC))) endif # MISCOBJS is a list of misc. objects not in the above categories @@ -545,7 +550,8 @@ DOCSCRUFT += $(patsubst %.tex,%.toc, $(f # DEPENDS is a global list of all of our dependency files. # NOTE: sort is just a trick to remove duplicates; the order # doesn't matter at all. -DEPENDS := $(sort $(LIBDEPENDS) $(SERVERDEPENDS) $(MISCDEPENDS) \ +DEPENDS := $(sort $(LIBDEPENDS) $(SERVERDEPENDS) $(SERVERBINDEPENDS) \ + $(MISCDEPENDS) \ $(ADMINDEPENDS) $(ADMINDEPENDS_SERVER) $(KERNAPPDEPENDS) $(VISDEPENDS) \ $(VISMISCDEPENDS) $(KARMADEPENDS) $(STATECOMPDEPS)) @@ -603,7 +609,7 @@ modldflags = $(MODLDFLAGS_$(call canonna # SHORT_NAME and the object # rule for building the pvfs2 server -$(SERVER): src/server/pvfs2-server-server.o lib/libpvfs2-server.a +$(SERVER): $(SERVERBINOBJS) lib/libpvfs2-server.a $(Q) " LD $@" $(E)$(LD) $^ -o $@ $(SERVER_LDFLAGS) $(SERVERLIBS) @@ -769,7 +775,8 @@ docsclean: # top rule for cleaning up tree clean:: $(Q) " CLEAN" - $(E)rm -f $(LIBOBJS) $(LIBTHREADEDOBJS) $(SERVEROBJS) $(MISCOBJS) \ + $(E)rm -f $(LIBOBJS) $(LIBTHREADEDOBJS) \ + $(SERVEROBJS) $(SERVERBINOBJS) $(MISCOBJS) \ $(LIBRARIES) $(LIBRARIES_THREADED) $(DEPENDS) $(SERVER) \ $(ADMINOBJS) $(ADMINOBJS_SERVER) $(ADMINTOOLS)\ $(ADMINTOOLS_SERVER) lib/libpvfs2-server.a\ Index: src/io/job/job.c =================================================================== RCS file: /projects/cvsroot/pvfs2/src/io/job/job.c,v retrieving revision 1.177 diff -u -a -p -r1.177 job.c --- src/io/job/job.c 10 Jan 2008 19:50:37 -0000 1.177 +++ src/io/job/job.c 9 Feb 2008 21:58:49 -0000 @@ -962,8 +962,11 @@ int job_dev_write_list(void** buffer_lis * returns 0 on success, -errno on failure, and 1 on immediate * completion */ -int job_req_sched_post(struct PVFS_server_req *in_request, - int req_index, +int job_req_sched_post(enum PVFS_server_op op, + PVFS_fs_id fs_id, + PVFS_handle handle, + int read_only, + int schedule, void *user_ptr, job_aint status_user_tag, job_status_s * out_status_p, @@ -993,7 +996,8 @@ int job_req_sched_post(struct PVFS_serve jd->context_id = context_id; jd->status_user_tag = status_user_tag; - ret = PINT_req_sched_post(in_request, req_index, jd, &(jd->u.req_sched.id)); + ret = PINT_req_sched_post( + op, fs_id, handle, read_only, schedule, jd, &(jd->u.req_sched.id)); if (ret < 0) { @@ -1020,6 +1024,51 @@ int job_req_sched_post(struct PVFS_serve */ *id = jd->job_id; + return (0); +} + +int job_req_sched_change_mode(enum PVFS_server_mode mode, + void *user_ptr, + job_aint status_user_tag, + job_status_s *out_status_p, + job_id_t *id, + job_context_id context_id) +{ + struct job_desc *jd = NULL; + int ret = -1; + + jd = alloc_job_desc(JOB_REQ_SCHED); + if(!jd) + { + return (errno); + } + jd->job_user_ptr = user_ptr; + jd->u.req_sched.post_flag = 1; + jd->context_id = context_id; + jd->status_user_tag = status_user_tag; + + ret = PINT_req_sched_change_mode(mode, jd, &(jd->u.req_sched.id)); + if (ret < 0) + { + /* error posting */ + dealloc_job_desc(jd); + jd = NULL; + out_status_p->error_code = ret; + out_status_p->status_user_tag = status_user_tag; + return (1); + } + + if (ret == 1) + { + /* immediate completion */ + out_status_p->error_code = 0; + out_status_p->status_user_tag = status_user_tag; + *id = jd->job_id; + /* don't delete the job desc until a matching release comes through */ + return (1); + } + + *id = jd->job_id; return (0); } Index: src/io/job/job.h =================================================================== RCS file: /projects/cvsroot/pvfs2/src/io/job/job.h,v retrieving revision 1.54 diff -u -a -p -r1.54 job.h --- src/io/job/job.h 13 Sep 2006 20:22:52 -0000 1.54 +++ src/io/job/job.h 9 Feb 2008 21:58:49 -0000 @@ -170,13 +170,24 @@ int job_dev_write_list(void** buffer_lis job_context_id context_id); /* request scheduler post */ -int job_req_sched_post(struct PVFS_server_req *in_request, - int req_index, +int job_req_sched_post(enum PVFS_server_op op, + PVFS_fs_id fs_id, + PVFS_handle handle, + int readonly, + int schedule, void *user_ptr, job_aint status_user_tag, job_status_s * out_status_p, job_id_t * id, job_context_id context_id); + +/* change the mode */ +int job_req_sched_change_mode(enum PVFS_server_mode mode, + void *user_ptr, + job_aint status_user_tag, + job_status_s *out_status_p, + job_id_t *id, + job_context_id context_id); int job_req_sched_post_timer(int msecs, void *user_ptr, Index: src/proto/pvfs2-req-proto.h =================================================================== RCS file: /projects/cvsroot/pvfs2/src/proto/pvfs2-req-proto.h,v retrieving revision 1.151 diff -u -a -p -r1.151 pvfs2-req-proto.h --- src/proto/pvfs2-req-proto.h 17 Aug 2007 04:04:27 -0000 1.151 +++ src/proto/pvfs2-req-proto.h 9 Feb 2008 21:58:50 -0000 @@ -408,7 +408,7 @@ struct PVFS_servreq_lookup_path { char *path; /* path name */ PVFS_fs_id fs_id; /* file system */ - PVFS_handle starting_handle; /* handle of path parent */ + PVFS_handle handle; /* handle of path parent */ /* mask of attribs to return with lookup results */ uint32_t attrmask; }; @@ -417,7 +417,7 @@ endecode_fields_5_struct( string, path, PVFS_fs_id, fs_id, skip4,, - PVFS_handle, starting_handle, + PVFS_handle, handle, uint32_t, attrmask) #define extra_size_PVFS_servreq_lookup_path \ roundup8(PVFS_REQ_LIMIT_PATH_NAME_BYTES + 1) @@ -434,7 +434,7 @@ do { (__req).credentials = (__creds); \ (__req).u.lookup_path.path = (__path); \ (__req).u.lookup_path.fs_id = (__fsid); \ - (__req).u.lookup_path.starting_handle = (__handle);\ + (__req).u.lookup_path.handle = (__handle);\ (__req).u.lookup_path.attrmask = (__amask); \ } while (0) @@ -519,14 +519,14 @@ struct PVFS_servreq_crdirent { char *name; /* name of new entry */ PVFS_handle new_handle; /* handle of new entry */ - PVFS_handle parent_handle; /* handle of directory */ + PVFS_handle handle; /* handle of directory */ PVFS_fs_id fs_id; /* file system */ }; endecode_fields_4_struct( PVFS_servreq_crdirent, string, name, PVFS_handle, new_handle, - PVFS_handle, parent_handle, + PVFS_handle, handle, PVFS_fs_id, fs_id) #define extra_size_PVFS_servreq_crdirent \ roundup8(PVFS_REQ_LIMIT_SEGMENT_BYTES+1) @@ -535,7 +535,7 @@ endecode_fields_4_struct( __creds, \ __name, \ __new_handle, \ - __parent_handle, \ + __handle, \ __fs_id) \ do { \ memset(&(__req), 0, sizeof(__req)); \ @@ -543,8 +543,8 @@ do { (__req).credentials = (__creds); \ (__req).u.crdirent.name = (__name); \ (__req).u.crdirent.new_handle = (__new_handle); \ - (__req).u.crdirent.parent_handle = \ - (__parent_handle); \ + (__req).u.crdirent.handle = \ + (__handle); \ (__req).u.crdirent.fs_id = (__fs_id); \ } while (0) @@ -554,13 +554,13 @@ do { struct PVFS_servreq_rmdirent { char *entry; /* name of entry to remove */ - PVFS_handle parent_handle; /* handle of directory */ + PVFS_handle handle; /* handle of directory */ PVFS_fs_id fs_id; /* file system */ }; endecode_fields_3_struct( PVFS_servreq_rmdirent, string, entry, - PVFS_handle, parent_handle, + PVFS_handle, handle, PVFS_fs_id, fs_id) #define extra_size_PVFS_servreq_rmdirent \ roundup8(PVFS_REQ_LIMIT_SEGMENT_BYTES+1) @@ -575,7 +575,7 @@ do { (__req).op = PVFS_SERV_RMDIRENT; \ (__req).credentials = (__creds); \ (__req).u.rmdirent.fs_id = (__fsid); \ - (__req).u.rmdirent.parent_handle = (__handle);\ + (__req).u.rmdirent.handle = (__handle); \ (__req).u.rmdirent.entry = (__entry); \ } while (0); @@ -594,14 +594,14 @@ struct PVFS_servreq_chdirent { char *entry; /* name of entry to remove */ PVFS_handle new_dirent_handle; /* handle of directory */ - PVFS_handle parent_handle; /* handle of directory */ + PVFS_handle handle; /* handle of directory */ PVFS_fs_id fs_id; /* file system */ }; endecode_fields_4_struct( PVFS_servreq_chdirent, string, entry, PVFS_handle, new_dirent_handle, - PVFS_handle, parent_handle, + PVFS_handle, handle, PVFS_fs_id, fs_id) #define extra_size_PVFS_servreq_chdirent \ roundup8(PVFS_REQ_LIMIT_SEGMENT_BYTES+1) @@ -609,7 +609,7 @@ endecode_fields_4_struct( #define PINT_SERVREQ_CHDIRENT_FILL(__req, \ __creds, \ __fsid, \ - __parent_handle,\ + __handle, \ __new_dirent, \ __entry) \ do { \ @@ -617,8 +617,8 @@ do { (__req).op = PVFS_SERV_CHDIRENT; \ (__req).credentials = (__creds); \ (__req).u.chdirent.fs_id = (__fsid); \ - (__req).u.chdirent.parent_handle = \ - (__parent_handle); \ + (__req).u.chdirent.handle = \ + (__handle); \ (__req).u.chdirent.new_dirent_handle = \ (__new_dirent); \ (__req).u.chdirent.entry = (__entry); \ Index: src/server/chdirent.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/chdirent.sm,v retrieving revision 1.18 diff -u -a -p -r1.18 chdirent.sm --- src/server/chdirent.sm 30 Aug 2007 00:13:44 -0000 1.18 +++ src/server/chdirent.sm 9 Feb 2008 21:58:50 -0000 @@ -115,7 +115,7 @@ static PINT_sm_action chdirent_verify_pa " reading dirdata handle (coll_id = 0x%x, handle = %llu, " "key = %s (%d), val_buf = %p (%d))\n", s_op->req->u.chdirent.fs_id, - llu(s_op->req->u.chdirent.parent_handle), + llu(s_op->req->u.chdirent.handle), (char *) s_op->key.buffer, s_op->key.buffer_sz, s_op->val.buffer, @@ -123,7 +123,7 @@ static PINT_sm_action chdirent_verify_pa ret = job_trove_keyval_read( s_op->req->u.chdirent.fs_id, - s_op->req->u.chdirent.parent_handle, + s_op->req->u.chdirent.handle, &s_op->key, &s_op->val, 0, @@ -266,7 +266,7 @@ static PINT_sm_action chdirent_update_di PVFS_object_attr_to_ds_attr(tmp_attr_ptr, ds_attr); ret = job_trove_dspace_setattr( - s_op->req->u.chdirent.fs_id, s_op->req->u.chdirent.parent_handle, + s_op->req->u.chdirent.fs_id, s_op->req->u.chdirent.handle, ds_attr, TROVE_SYNC | 0, @@ -318,6 +318,18 @@ static PINT_sm_action chdirent_cleanup( { return (server_state_machine_complete(smcb)); } + +PINT_GET_OBJECT_REF_DEFINE(chdirent); + +struct PINT_server_req_params pvfs2_chdirent_params = +{ + .string_name = "chdirent", + .perm = PINT_SERVER_CHECK_WRITE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_chdirent, + .state_machine = &pvfs2_chdirent_sm +}; /* * Local variables: Index: src/server/crdirent.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/crdirent.sm,v retrieving revision 1.68 diff -u -a -p -r1.68 crdirent.sm --- src/server/crdirent.sm 30 Aug 2007 00:13:44 -0000 1.68 +++ src/server/crdirent.sm 9 Feb 2008 21:58:50 -0000 @@ -326,7 +326,7 @@ static PINT_sm_action crdirent_update_di PVFS_object_attr_to_ds_attr(tmp_attr_ptr, ds_attr); ret = job_trove_dspace_setattr( - s_op->req->u.crdirent.fs_id, s_op->req->u.crdirent.parent_handle, + s_op->req->u.crdirent.fs_id, s_op->req->u.crdirent.handle, ds_attr, TROVE_SYNC, smcb, 0, js_p, &j_id, server_job_context); @@ -355,13 +355,25 @@ static PINT_sm_action crdirent_setup_op( s_op->u.crdirent.name = s_op->req->u.crdirent.name; s_op->u.crdirent.new_handle = s_op->req->u.crdirent.new_handle; - s_op->u.crdirent.parent_handle = s_op->req->u.crdirent.parent_handle; + s_op->u.crdirent.parent_handle = s_op->req->u.crdirent.handle; s_op->u.crdirent.fs_id = s_op->req->u.crdirent.fs_id; s_op->u.crdirent.dir_attr_update_required = 0; js_p->error_code = 0; return SM_ACTION_COMPLETE; } + +PINT_GET_OBJECT_REF_DEFINE(crdirent); + +struct PINT_server_req_params pvfs2_crdirent_params = +{ + .string_name = "crdirent", + .perm = PINT_SERVER_CHECK_CRDIRENT, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_crdirent, + .state_machine = &pvfs2_crdirent_sm +}; /* * Local variables: Index: src/server/create.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/create.sm,v retrieving revision 1.46 diff -u -a -p -r1.46 create.sm --- src/server/create.sm 30 Aug 2007 00:13:44 -0000 1.46 +++ src/server/create.sm 9 Feb 2008 21:58:50 -0000 @@ -158,6 +158,22 @@ static int create_cleanup( return(server_state_machine_complete(smcb)); } +static inline int PINT_get_object_ref_create( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = req->u.create.fs_id; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_create_params = +{ + .string_name = "create", + .get_object_ref = PINT_get_object_ref_create, + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .state_machine = &pvfs2_create_sm +}; /* * Local variables: Index: src/server/del-eattr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/del-eattr.sm,v retrieving revision 1.14 diff -u -a -p -r1.14 del-eattr.sm --- src/server/del-eattr.sm 7 Dec 2007 23:08:46 -0000 1.14 +++ src/server/del-eattr.sm 9 Feb 2008 21:58:50 -0000 @@ -195,6 +195,18 @@ static PINT_sm_action deleattr_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(deleattr); + +struct PINT_server_req_params pvfs2_del_eattr_params = +{ + .string_name = "del_eattr", + .perm = PINT_SERVER_CHECK_ATTR, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_deleattr, + .state_machine = &pvfs2_del_eattr_sm +}; + /* * Local variables: * mode: c Index: src/server/event-mon.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/event-mon.sm,v retrieving revision 1.8 diff -u -a -p -r1.8 event-mon.sm --- src/server/event-mon.sm 30 Aug 2007 00:13:44 -0000 1.8 +++ src/server/event-mon.sm 9 Feb 2008 21:58:50 -0000 @@ -89,7 +89,21 @@ static PINT_sm_action event_mon_do_work( return SM_ACTION_COMPLETE; } +static inline int PINT_get_object_ref_mgmt_event_mon( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = PVFS_FS_ID_NULL; + *handle = PVFS_HANDLE_NULL; + return 0; +}; +struct PINT_server_req_params pvfs2_event_mon_params = +{ + .string_name = "mgmt_event_mon", + .perm = PINT_SERVER_CHECK_NONE, + .get_object_ref = PINT_get_object_ref_mgmt_event_mon, + .state_machine = &pvfs2_event_mon_sm +}; /* * Local variables: Index: src/server/final-response.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/final-response.sm,v retrieving revision 1.37 diff -u -a -p -r1.37 final-response.sm --- src/server/final-response.sm 24 Jan 2008 20:28:40 -0000 1.37 +++ src/server/final-response.sm 9 Feb 2008 21:58:50 -0000 @@ -162,58 +162,10 @@ static PINT_sm_action final_response_cle PINT_encode_release(&s_op->encoded, PINT_ENCODE_RESP); - /* decrement reference count for this bmi address */ - BMI_set_info(s_op->addr, BMI_DEC_ADDR_REF, NULL); - js_p->error_code = 0; return SM_ACTION_COMPLETE; } - -static const struct { - enum PVFS_server_op type; - const char *type_str; -} s_req_resp_type_map[] = { - /* WARNING: THESE MUST BE LISTED IN ORDER */ - { PVFS_SERV_INVALID, "PVFS_SERV_INVALID"}, /* 0 */ - { PVFS_SERV_CREATE, "PVFS_SERV_CREATE" }, - { PVFS_SERV_REMOVE, "PVFS_SERV_REMOVE" }, - { PVFS_SERV_IO, "PVFS_SERV_IO" }, - { PVFS_SERV_GETATTR, "PVFS_SERV_GETATTR" }, - { PVFS_SERV_SETATTR, "PVFS_SERV_SETATTR" }, - { PVFS_SERV_LOOKUP_PATH, "PVFS_SERV_LOOKUP_PATH" }, - { PVFS_SERV_CRDIRENT, "PVFS_SERV_CRDIRENT" }, - { PVFS_SERV_RMDIRENT, "PVFS_SERV_RMDIRENT" }, - { PVFS_SERV_CHDIRENT, "PVFS_SERV_CHDIRENT" }, - { PVFS_SERV_TRUNCATE, "PVFS_SERV_TRUNCATE" }, /* 10 */ - { PVFS_SERV_MKDIR, "PVFS_SERV_MKDIR" }, - { PVFS_SERV_READDIR, "PVFS_SERV_READDIR" }, - { PVFS_SERV_GETCONFIG, "PVFS_SERV_GETCONFIG" }, - { PVFS_SERV_WRITE_COMPLETION, "PVFS_SERV_WRITE_COMPLETION" }, - { PVFS_SERV_FLUSH, "PVFS_SERV_FLUSH" }, - { PVFS_SERV_MGMT_SETPARAM, "PVFS_SERV_MGMT_SETPARAM" }, - { PVFS_SERV_MGMT_NOOP, "PVFS_SERV_MGMT_NOOP" }, - { PVFS_SERV_STATFS, "PVFS_SERV_STATFS" }, - { PVFS_SERV_PERF_UPDATE, "PVFS_SERV_PERF_UPDATE" }, - { PVFS_SERV_MGMT_PERF_MON, "PVFS_SERV_MGMT_PERF_MON" }, /* 20 */ - { PVFS_SERV_MGMT_ITERATE_HANDLES, "PVFS_SERV_MGMT_ITERATE_HANDLES" }, - { PVFS_SERV_MGMT_DSPACE_INFO_LIST, - "PVFS_SERV_MGMT_DSPACE_INFO_LIST" }, - { PVFS_SERV_MGMT_EVENT_MON, "PVFS_SERV_MGMT_EVENT_MON" }, - { PVFS_SERV_MGMT_REMOVE_OBJECT, "PVFS_SERV_MGMT_REMOVE_OBJECT" }, - { PVFS_SERV_MGMT_REMOVE_DIRENT, "PVFS_SERV_MGMT_REMOVE_DIRENT" }, - { PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, - "PVFS_SERV_MGMT_GET_DIRDATA_HANDLE" }, - { PVFS_SERV_JOB_TIMER, "PVFS_SERV_JOB_TIMER" }, - { PVFS_SERV_PROTO_ERROR, "PVFS_SERV_PROTO_ERROR" }, - { PVFS_SERV_GETEATTR, "PVFS_SERV_GETEATTR" }, - { PVFS_SERV_SETEATTR, "PVFS_SERV_SETEATTR" }, /* 30 */ - { PVFS_SERV_DELEATTR, "PVFS_SERV_DELEATTR" }, - { PVFS_SERV_LISTEATTR, "PVFS_SERV_LISTEATTR" }, - { PVFS_SERV_SMALL_IO, "PVFS_SERV_SMALL_IO" }, - { PVFS_SERV_LISTATTR, "PVFS_SERV_LISTATTR" } /* 34 */ -}; - static void PINT_gossip_err_server_resp( struct PVFS_server_resp *resp) { @@ -222,7 +174,7 @@ static void PINT_gossip_err_server_resp( if (resp->op >= 0 && resp->op < PVFS_SERV_NUM_OPS) { gossip_err("Server Response %p is of type: %s\n", - resp, s_req_resp_type_map[resp->op].type_str); + resp, PINT_map_server_op_to_string(resp->op)); } else { Index: src/server/flush.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/flush.sm,v retrieving revision 1.22 diff -u -a -p -r1.22 flush.sm --- src/server/flush.sm 30 Aug 2007 00:13:44 -0000 1.22 +++ src/server/flush.sm 9 Feb 2008 21:58:50 -0000 @@ -195,6 +195,18 @@ static PINT_sm_action flush_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(flush); + +struct PINT_server_req_params pvfs2_flush_params = +{ + .string_name = "flush", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_flush, + .state_machine = &pvfs2_flush_sm +}; + /* * Local variables: * mode: c Index: src/server/get-attr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/get-attr.sm,v retrieving revision 1.87 diff -u -a -p -r1.87 get-attr.sm --- src/server/get-attr.sm 30 Aug 2007 00:13:44 -0000 1.87 +++ src/server/get-attr.sm 9 Feb 2008 21:58:50 -0000 @@ -1087,6 +1087,18 @@ static PINT_sm_action getattr_interpret_ return SM_ACTION_COMPLETE; } +PINT_GET_OBJECT_REF_DEFINE(getattr); + +struct PINT_server_req_params pvfs2_get_attr_params = +{ + .string_name = "getattr", + .perm = PINT_SERVER_CHECK_ATTR, + .access_type = PINT_server_req_readonly, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_getattr, + .state_machine = &pvfs2_get_attr_sm +}; + /* * Local variables: * mode: c Index: src/server/get-config.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/get-config.sm,v retrieving revision 1.38 diff -u -a -p -r1.38 get-config.sm --- src/server/get-config.sm 30 Aug 2007 00:13:44 -0000 1.38 +++ src/server/get-config.sm 9 Feb 2008 21:58:50 -0000 @@ -104,6 +104,21 @@ static PINT_sm_action getconfig_cleanup( return(server_state_machine_complete(smcb)); } +static inline int PINT_get_object_ref_getconfig( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = PVFS_FS_ID_NULL; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_get_config_params = +{ + .string_name = "getconfig", + .get_object_ref = PINT_get_object_ref_getconfig, + .perm = PINT_SERVER_CHECK_NONE, + .state_machine = &pvfs2_get_config_sm +}; /* * Local variables: Index: src/server/get-eattr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/get-eattr.sm,v retrieving revision 1.19 diff -u -a -p -r1.19 get-eattr.sm --- src/server/get-eattr.sm 30 Aug 2007 00:13:44 -0000 1.19 +++ src/server/get-eattr.sm 9 Feb 2008 21:58:50 -0000 @@ -234,6 +234,17 @@ static PINT_sm_action geteattr_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(geteattr); + +struct PINT_server_req_params pvfs2_get_eattr_params = +{ + .string_name = "get_eattr", + .perm = PINT_SERVER_CHECK_ATTR, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_geteattr, + .state_machine = &pvfs2_get_eattr_sm +}; + /* * Local variables: * mode: c Index: src/server/io.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/io.sm,v retrieving revision 1.68 diff -u -a -p -r1.68 io.sm --- src/server/io.sm 30 Aug 2007 00:13:44 -0000 1.68 +++ src/server/io.sm 9 Feb 2008 21:58:50 -0000 @@ -386,6 +386,28 @@ static PINT_sm_action io_send_completion return err; } +static inline int PINT_server_req_access_io( + struct PVFS_server_req *req) +{ + if(req->u.io.io_type == PVFS_IO_READ) + { + return 1; + } + return 0; +} + +PINT_GET_OBJECT_REF_DEFINE(io); + +struct PINT_server_req_params pvfs2_io_params = +{ + .string_name = "io", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_access_io, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_io, + .state_machine = &pvfs2_io_sm +}; + /* * Local variables: * mode: c Index: src/server/iterate-handles.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/iterate-handles.sm,v retrieving revision 1.10 diff -u -a -p -r1.10 iterate-handles.sm --- src/server/iterate-handles.sm 18 Oct 2007 17:55:05 -0000 1.10 +++ src/server/iterate-handles.sm 9 Feb 2008 21:58:50 -0000 @@ -129,6 +129,22 @@ static PINT_sm_action iterate_handles_fi return SM_ACTION_COMPLETE; } +static inline int PINT_get_object_ref_iterate_handles( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = req->u.mgmt_iterate_handles.fs_id; + *handle = PVFS_HANDLE_NULL; + return 0; +} + +struct PINT_server_req_params pvfs2_iterate_handles_params = +{ + .string_name = "mgmt_iterate_handles", + .perm = PINT_SERVER_CHECK_NONE, + .get_object_ref = PINT_get_object_ref_iterate_handles, + .state_machine = &pvfs2_iterate_handles_sm +}; + /* * Local variables: * mode: c Index: src/server/job-timer.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/job-timer.sm,v retrieving revision 1.6 diff -u -a -p -r1.6 job-timer.sm --- src/server/job-timer.sm 30 Aug 2007 00:13:44 -0000 1.6 +++ src/server/job-timer.sm 9 Feb 2008 21:58:50 -0000 @@ -80,6 +80,13 @@ static PINT_sm_action job_timer_do_work( server_job_context)); } +struct PINT_server_req_params pvfs2_job_timer_params = +{ + .string_name = "job_timer", + .perm = PINT_SERVER_CHECK_INVALID, + .state_machine = &pvfs2_job_timer_sm +}; + Index: src/server/list-attr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/list-attr.sm,v retrieving revision 1.7 diff -u -a -p -r1.7 list-attr.sm --- src/server/list-attr.sm 30 Aug 2007 00:13:44 -0000 1.7 +++ src/server/list-attr.sm 9 Feb 2008 21:58:50 -0000 @@ -802,6 +802,24 @@ static PINT_sm_action listattr_interpret return SM_ACTION_COMPLETE; } +static inline int PINT_get_object_ref_listattr( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = req->u.listattr.fs_id; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_list_attr_params = +{ + .string_name = "list_attr", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_readonly, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_listattr, + .state_machine = &pvfs2_list_attr_sm +}; + /* * Local variables: * mode: c Index: src/server/list-eattr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/list-eattr.sm,v retrieving revision 1.12 diff -u -a -p -r1.12 list-eattr.sm --- src/server/list-eattr.sm 30 Aug 2007 00:13:44 -0000 1.12 +++ src/server/list-eattr.sm 9 Feb 2008 21:58:50 -0000 @@ -238,6 +238,17 @@ static PINT_sm_action listeattr_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(listeattr); + +struct PINT_server_req_params pvfs2_list_eattr_params = +{ + .string_name = "listeattr", + .perm = PINT_SERVER_CHECK_ATTR, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_listeattr, + .state_machine = &pvfs2_list_eattr_sm +}; + /* * Local variables: * mode: c Index: src/server/lookup.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/lookup.sm,v retrieving revision 1.56 diff -u -a -p -r1.56 lookup.sm --- src/server/lookup.sm 30 Aug 2007 00:13:44 -0000 1.56 +++ src/server/lookup.sm 9 Feb 2008 21:58:50 -0000 @@ -146,7 +146,7 @@ static PINT_sm_action lookup_init( "(# of segments:%u)\n", s_op->req->u.lookup_path.path, s_op->req->u.lookup_path.fs_id, - llu(s_op->req->u.lookup_path.starting_handle), + llu(s_op->req->u.lookup_path.handle), s_op->req->u.lookup_path.attrmask, s_op->u.lookup.seg_ct); if ((s_op->u.lookup.seg_ct < 0) || @@ -217,7 +217,7 @@ static PINT_sm_action lookup_read_object /* use the base handle if we haven't looked up a segment yet */ if (s_op->u.lookup.seg_nr == 0) { - handle = s_op->req->u.lookup_path.starting_handle; + handle = s_op->req->u.lookup_path.handle; ds_attr = &(s_op->u.lookup.ds_attr_array[0]); } else @@ -500,7 +500,7 @@ static PINT_sm_action lookup_read_direct /* use the base handle if we haven't looked up a segment yet */ if (s_op->u.lookup.seg_nr == 0) { - handle = s_op->req->u.lookup_path.starting_handle; + handle = s_op->req->u.lookup_path.handle; } else { @@ -652,6 +652,17 @@ static PINT_sm_action lookup_cleanup( } return(server_state_machine_complete(smcb)); } + +PINT_GET_OBJECT_REF_DEFINE(lookup_path); + +struct PINT_server_req_params pvfs2_lookup_params = +{ + .string_name = "lookup_path", + .perm = PINT_SERVER_CHECK_NONE, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_lookup_path, + .state_machine = &pvfs2_lookup_sm +}; /* * Local variables: Index: src/server/mgmt-get-dirdata-handle.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/mgmt-get-dirdata-handle.sm,v retrieving revision 1.9 diff -u -a -p -r1.9 mgmt-get-dirdata-handle.sm --- src/server/mgmt-get-dirdata-handle.sm 30 Aug 2007 00:13:44 -0000 1.9 +++ src/server/mgmt-get-dirdata-handle.sm 9 Feb 2008 21:58:50 -0000 @@ -117,6 +117,17 @@ static PINT_sm_action mgmt_get_dirdata_h return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(mgmt_get_dirdata_handle); + +struct PINT_server_req_params pvfs2_mgmt_get_dirdata_handle_params = +{ + .string_name = "mgmt-get-dirdata-handle", + .perm = PINT_SERVER_CHECK_NONE, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_mgmt_get_dirdata_handle, + .state_machine = &pvfs2_mgmt_get_dirdata_handle_sm +}; + /* * Local variables: * mode: c Index: src/server/mgmt-remove-dirent.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/mgmt-remove-dirent.sm,v retrieving revision 1.13 diff -u -a -p -r1.13 mgmt-remove-dirent.sm --- src/server/mgmt-remove-dirent.sm 30 Aug 2007 00:13:44 -0000 1.13 +++ src/server/mgmt-remove-dirent.sm 9 Feb 2008 21:58:50 -0000 @@ -125,6 +125,18 @@ static PINT_sm_action mgmt_remove_dirent return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(mgmt_remove_dirent); + +struct PINT_server_req_params pvfs2_mgmt_remove_dirent_params = +{ + .string_name = "mgmt-remove-dirent", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_mgmt_remove_dirent, + .state_machine = &pvfs2_mgmt_remove_dirent_sm +}; + /* * Local variables: * mode: c Index: src/server/mgmt-remove-object.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/mgmt-remove-object.sm,v retrieving revision 1.13 diff -u -a -p -r1.13 mgmt-remove-object.sm --- src/server/mgmt-remove-object.sm 30 Aug 2007 00:13:44 -0000 1.13 +++ src/server/mgmt-remove-object.sm 9 Feb 2008 21:58:50 -0000 @@ -77,6 +77,18 @@ static PINT_sm_action mgmt_remove_cleanu return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(mgmt_remove_object); + +struct PINT_server_req_params pvfs2_mgmt_remove_object_params = +{ + .string_name = "mgmt-remove-object", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_mgmt_remove_object, + .state_machine = &pvfs2_mgmt_remove_object_sm +}; + /* * Local variables: * mode: c Index: src/server/mkdir.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/mkdir.sm,v retrieving revision 1.50 diff -u -a -p -r1.50 mkdir.sm --- src/server/mkdir.sm 30 Aug 2007 00:13:44 -0000 1.50 +++ src/server/mkdir.sm 9 Feb 2008 21:58:50 -0000 @@ -308,6 +308,22 @@ static PINT_sm_action mkdir_prep_sm( return SM_ACTION_COMPLETE; } +static inline int PINT_get_object_ref_mkdir( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = req->u.mkdir.fs_id; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_mkdir_params = +{ + .string_name = "mkdir", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .state_machine = &pvfs2_mkdir_sm +}; + /* * Local variables: * mode: c Index: src/server/module.mk.in =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/module.mk.in,v retrieving revision 1.52 diff -u -a -p -r1.52 module.mk.in --- src/server/module.mk.in 22 Jul 2007 16:22:04 -0000 1.52 +++ src/server/module.mk.in 9 Feb 2008 21:58:50 -0000 @@ -53,8 +53,8 @@ ifdef BUILD_SERVER SMCGEN += $(SERVER_SMCGEN) # server code that will be linked manually, not included in library - MISCSRC += \ - $(DIR)/pvfs2-server.c + SERVERBINSRC += \ + $(DIR)/pvfs2-server.c $(DIR)/pvfs2-server-req.c # to stat the fs, need to know about handle statistics MODCFLAGS_$(DIR)/statfs.c = \ Index: src/server/noop.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/noop.sm,v retrieving revision 1.7 diff -u -a -p -r1.7 noop.sm --- src/server/noop.sm 30 Aug 2007 00:13:44 -0000 1.7 +++ src/server/noop.sm 9 Feb 2008 21:58:50 -0000 @@ -48,6 +48,22 @@ static PINT_sm_action noop_cleanup( return(server_state_machine_complete(smcb)); } +static inline int PINT_get_object_ref_noop( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = PVFS_FS_ID_NULL; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_noop_params = +{ + .string_name = "noop", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_readonly, + .get_object_ref = PINT_get_object_ref_noop, + .state_machine = &pvfs2_noop_sm +}; /* * Local variables: Index: src/server/perf-mon.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/perf-mon.sm,v retrieving revision 1.14 diff -u -a -p -r1.14 perf-mon.sm --- src/server/perf-mon.sm 30 Aug 2007 00:13:44 -0000 1.14 +++ src/server/perf-mon.sm 9 Feb 2008 21:58:50 -0000 @@ -312,6 +312,22 @@ static int reallocate_static_arrays_if_n return(0); } +static inline int PINT_get_object_ref_mgmt_perf_mon( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = PVFS_FS_ID_NULL; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_perf_mon_params = +{ + .string_name = "mgmt_perf_mon", + .perm = PINT_SERVER_CHECK_NONE, + .get_object_ref = PINT_get_object_ref_mgmt_perf_mon, + .state_machine = &pvfs2_perf_mon_sm +}; + /* * Local variables: * mode: c Index: src/server/perf-update.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/perf-update.sm,v retrieving revision 1.11 diff -u -a -p -r1.11 perf-update.sm --- src/server/perf-update.sm 30 Aug 2007 00:13:44 -0000 1.11 +++ src/server/perf-update.sm 9 Feb 2008 21:58:50 -0000 @@ -100,6 +100,12 @@ static PINT_sm_action perf_update_do_wor server_job_context)); } +struct PINT_server_req_params pvfs2_perf_update_params = +{ + .string_name = "perf_update", + .state_machine = &pvfs2_perf_update_sm +}; + Index: src/server/prelude.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/prelude.sm,v retrieving revision 1.72 diff -u -a -p -r1.72 prelude.sm --- src/server/prelude.sm 7 Dec 2007 23:08:46 -0000 1.72 +++ src/server/prelude.sm 9 Feb 2008 21:58:50 -0000 @@ -29,7 +29,7 @@ enum { %% -nested machine pvfs2_prelude_sm +nested machine pvfs2_prelude_work_sm { state req_sched { @@ -64,8 +64,37 @@ nested machine pvfs2_prelude_sm } } +nested machine pvfs2_prelude_sm +{ + state setup + { + run prelude_setup; + default => prelude_work; + } + + state prelude_work + { + jump pvfs2_prelude_work_sm; + default => return; + } +} + %% +static PINT_sm_action prelude_setup( + 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); + + return SM_ACTION_COMPLETE; +} + /* prelude_req_sched() * * posts a request scheduler job @@ -82,23 +111,9 @@ static PINT_sm_action prelude_req_sched( PINT_ACCESS_DEBUG(s_op, GOSSIP_ACCESS_DETAIL_DEBUG, "request\n"); - /* this is the first state for every normal pvfs2 server state - * machine, so we get to do some housekeeping here. In - * particular, bump up the reference count on the bmi address that - * we are using - */ - BMI_set_info(s_op->addr, BMI_INC_ADDR_REF, NULL); - - /* this is a bit of a hack; if we are changing server mode we must - * preserve the old mode value before calling req scheduler - */ - if ((s_op->op == PVFS_SERV_MGMT_SETPARAM) && - (s_op->req->u.mgmt_setparam.param == PVFS_SERV_PARAM_MODE)) - { - s_op->resp.u.mgmt_setparam.old_value = PINT_req_sched_get_mode(); - } - - ret = job_req_sched_post(s_op->req, 0, smcb, 0, js_p, + 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); PINT_perf_count(PINT_server_pc, PINT_PERF_REQSCHED, 1, PINT_PERF_ADD); @@ -114,7 +129,7 @@ static PINT_sm_action prelude_getattr_if struct PINT_smcb *smcb, job_status_s *js_p) { struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT); - int ret = -PVFS_EINVAL, readonly_flag = 0; + int ret = -PVFS_EINVAL; job_id_t tmp_id; PINT_ACCESS_DEBUG(s_op, GOSSIP_ACCESS_DETAIL_DEBUG, "start\n"); @@ -123,23 +138,6 @@ static PINT_sm_action prelude_getattr_if "(%p) %s (prelude sm) state: getattr_if_needed\n", s_op, PINT_map_server_op_to_string(s_op->req->op)); - /* first, run a request scheduler utility function that tells us - * what handle this request will operate on - */ - ret = PINT_req_sched_target_handle( - s_op->req, 0, &s_op->target_handle, - &s_op->target_fs_id, &readonly_flag); - - if (ret < 0) - { - gossip_debug(GOSSIP_SERVER_DEBUG, "PINT_req_sched_target_handle " - "returned %d ret, skipping getattr on handle %llu\n", - ret, llu(s_op->target_handle)); - - js_p->error_code = ret; - return SM_ACTION_COMPLETE; - } - /* if the handle is 0, that indicates that the request does not * operate on a specific handle, so there is nothing we can do * here @@ -165,137 +163,6 @@ static PINT_sm_action prelude_getattr_if return ret; } -static void get_fs_intent(struct PVFS_server_req *req, PVFS_fs_id *fsid, int *read_only) -{ - if (req == NULL) - { - *fsid = PVFS_FS_ID_NULL; - *read_only = -1; - return; - } - switch (req->op) - { - case PVFS_SERV_CREATE: - *fsid = req->u.create.fs_id; - *read_only = 0; - break; - case PVFS_SERV_REMOVE: - *fsid = req->u.remove.fs_id; - *read_only = 0; - break; - case PVFS_SERV_IO: - *fsid = req->u.io.fs_id; - *read_only = (req->u.io.io_type == PVFS_IO_READ) ? 1 : 0; - break; - case PVFS_SERV_SMALL_IO: - *fsid = req->u.small_io.fs_id; - *read_only = (req->u.small_io.io_type == PVFS_IO_READ) ? 1 : 0; - break; - case PVFS_SERV_GETATTR: - *fsid = req->u.getattr.fs_id; - *read_only = 1; - break; - case PVFS_SERV_LISTATTR: - *fsid = req->u.listattr.fs_id; - *read_only = 1; - break; - case PVFS_SERV_SETATTR: - *fsid = req->u.setattr.fs_id; - *read_only = 0; - break; - case PVFS_SERV_LOOKUP_PATH: - *fsid = req->u.lookup_path.fs_id; - *read_only = 1; - break; - case PVFS_SERV_CRDIRENT: - *fsid = req->u.crdirent.fs_id; - *read_only = 0; - break; - case PVFS_SERV_RMDIRENT: - *fsid = req->u.rmdirent.fs_id; - *read_only = 0; - break; - case PVFS_SERV_CHDIRENT: - *fsid = req->u.chdirent.fs_id; - *read_only = 0; - break; - case PVFS_SERV_TRUNCATE: - *fsid = req->u.truncate.fs_id; - *read_only = 0; - break; - case PVFS_SERV_MKDIR: - *fsid = req->u.mkdir.fs_id; - *read_only = 0; - break; - case PVFS_SERV_READDIR: - *fsid = req->u.readdir.fs_id; - *read_only = 1; - break; - case PVFS_SERV_FLUSH: - *fsid = req->u.flush.fs_id; - *read_only = 0; - break; - case PVFS_SERV_MGMT_SETPARAM: - *fsid = req->u.mgmt_setparam.fs_id; - *read_only = 0; - break; - case PVFS_SERV_STATFS: - *fsid = req->u.statfs.fs_id; - *read_only = 1; - break; - case PVFS_SERV_MGMT_ITERATE_HANDLES: - *fsid = req->u.mgmt_iterate_handles.fs_id; - *read_only = 1; - break; - case PVFS_SERV_MGMT_DSPACE_INFO_LIST: - *fsid = req->u.mgmt_dspace_info_list.fs_id; - *read_only = 1; - break; - case PVFS_SERV_MGMT_REMOVE_OBJECT: - *fsid = req->u.mgmt_remove_object.fs_id; - *read_only = 0; - break; - case PVFS_SERV_MGMT_REMOVE_DIRENT: - *fsid = req->u.mgmt_remove_dirent.fs_id; - *read_only = 0; - break; - case PVFS_SERV_MGMT_GET_DIRDATA_HANDLE: - *fsid = req->u.mgmt_get_dirdata_handle.fs_id; - *read_only = 0; - break; - case PVFS_SERV_GETEATTR: - *fsid = req->u.geteattr.fs_id; - *read_only = 1; - break; - case PVFS_SERV_SETEATTR: - *fsid = req->u.seteattr.fs_id; - *read_only = 0; - break; - case PVFS_SERV_DELEATTR: - *fsid = req->u.deleattr.fs_id; - *read_only = 0; - break; - case PVFS_SERV_LISTEATTR: - *fsid = req->u.listeattr.fs_id; - *read_only = 1; - break; - case PVFS_SERV_PROTO_ERROR: - case PVFS_SERV_JOB_TIMER: - case PVFS_SERV_MGMT_EVENT_MON: - case PVFS_SERV_MGMT_PERF_MON: - case PVFS_SERV_PERF_UPDATE: - case PVFS_SERV_MGMT_NOOP: - case PVFS_SERV_WRITE_COMPLETION: - case PVFS_SERV_GETCONFIG: - case PVFS_SERV_NUM_OPS: - case PVFS_SERV_INVALID: - *fsid = PVFS_FS_ID_NULL; - *read_only = -1; - break; - } - return; -} - static void get_anon_ids(struct filesystem_configuration_s *fsconfig, PVFS_uid *uid, PVFS_gid *gid) { @@ -473,7 +340,6 @@ static PINT_sm_action prelude_perm_check PVFS_uid translated_uid = s_op->req->credentials.uid; PVFS_gid translated_gid = s_op->req->credentials.gid; PVFS_fs_id fsid = PVFS_FS_ID_NULL; - int rdonly = -1; int squashed_flag = 0; int skip_acl_flag = 0; @@ -492,34 +358,14 @@ static PINT_sm_action prelude_perm_check /* Set the target object attribute pointer.. used later by the acl check */ s_op->target_object_attr = obj_attr; - /* Commenting out the below block for now. I think this code is - * deprecated? Even if not all of the attributes have been filled in - * yet, we should still be able to read them after the object has been - * created. If this change seems stable then we need to also come back - * and remove the PINT_SERVER_ATTRIBS_NOT_REQUIRED flag. -Phil 4-13-2006 - */ -#if 0 - /* the next thing we need to do is interpret the error code from - * reading the attributes. Normally it is an error if that step - * failed, but we have to look for the special case in which we - * set attributes on a file that did not have attributes - * previously. - */ - if (PINT_server_req_table[s_op->req->op].attrib_flags == - PINT_SERVER_ATTRIBS_NOT_REQUIRED) - { - js_p->error_code = 0; - } -#endif - - get_fs_intent(s_op->req, &fsid, &rdonly); - if (fsid != PVFS_FS_ID_NULL) + if (s_op->target_fs_id != PVFS_FS_ID_NULL) { /* * if we are exporting a volume readonly, disallow any operation that modifies * the state of the file-system. */ - if (permit_operation(fsid, rdonly, s_op->addr) < 0) + if (permit_operation( + s_op->target_fs_id, s_op->access_type, s_op->addr) < 0) { js_p->error_code = -PVFS_EROFS; return SM_ACTION_COMPLETE; @@ -566,7 +412,7 @@ static PINT_sm_action prelude_perm_check ((s_op->attr.mask & PVFS_ATTR_COMMON_GID) ? "yes" : "no"), s_op->attr.group, translated_gid); - switch(PINT_server_req_table[s_op->req->op].perm) + switch(PINT_server_req_get_perms(s_op->req)) { case PINT_SERVER_CHECK_WRITE: js_p->error_code = PINT_check_mode( @@ -633,7 +479,9 @@ static PINT_sm_action prelude_perm_check } break; case PINT_SERVER_CHECK_NONE: - if(squashed_flag && !rdonly && ((s_op->req->op == PVFS_SERV_IO) || + if(squashed_flag && + !PINT_server_req_get_access_type(s_op->req) && + ((s_op->req->op == PVFS_SERV_IO) || (s_op->req->op == PVFS_SERV_SMALL_IO) || (s_op->req->op == PVFS_SERV_TRUNCATE))) { @@ -754,7 +602,7 @@ static PINT_sm_action prelude_check_acls js_p->error_code = -PVFS_EINVAL; goto cleanup; } - switch (PINT_server_req_table[s_op->req->op].perm) + switch (PINT_server_req_get_perms(s_op->req)) { case PINT_SERVER_CHECK_WRITE: default: Index: src/server/proto-error.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/proto-error.sm,v retrieving revision 1.7 diff -u -a -p -r1.7 proto-error.sm --- src/server/proto-error.sm 30 Aug 2007 00:13:44 -0000 1.7 +++ src/server/proto-error.sm 9 Feb 2008 21:58:50 -0000 @@ -95,6 +95,12 @@ static PINT_sm_action proto_error_cleanu return(server_state_machine_complete(smcb)); } +struct PINT_server_req_params pvfs2_proto_error_params = +{ + .string_name = "proto_error", + .state_machine = &pvfs2_proto_error_sm +}; + /* * Local variables: Index: src/server/pvfs2-server-req.c =================================================================== RCS file: src/server/pvfs2-server-req.c diff -N src/server/pvfs2-server-req.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ src/server/pvfs2-server-req.c 9 Feb 2008 21:58:50 -0000 @@ -0,0 +1,158 @@ +/* + * (C) 2001 Clemson University and The University of Chicago + * + * See COPYING in top-level directory. + */ + +#include "pvfs2-server.h" + +/* server operation state machines */ +extern struct PINT_server_req_params pvfs2_get_config_params; +extern struct PINT_server_req_params pvfs2_get_attr_params; +extern struct PINT_server_req_params pvfs2_list_attr_params; +extern struct PINT_server_req_params pvfs2_set_attr_params; +extern struct PINT_server_req_params pvfs2_create_params; +extern struct PINT_server_req_params pvfs2_crdirent_params; +extern struct PINT_server_req_params pvfs2_mkdir_params; +extern struct PINT_server_req_params pvfs2_readdir_params; +extern struct PINT_server_req_params pvfs2_lookup_params; +extern struct PINT_server_req_params pvfs2_io_params; +extern struct PINT_server_req_params pvfs2_small_io_params; +extern struct PINT_server_req_params pvfs2_remove_params; +extern struct PINT_server_req_params pvfs2_mgmt_remove_object_params; +extern struct PINT_server_req_params pvfs2_mgmt_remove_dirent_params; +extern struct PINT_server_req_params pvfs2_mgmt_get_dirdata_handle_params; +extern struct PINT_server_req_params pvfs2_rmdirent_params; +extern struct PINT_server_req_params pvfs2_chdirent_params; +extern struct PINT_server_req_params pvfs2_flush_params; +extern struct PINT_server_req_params pvfs2_truncate_params; +extern struct PINT_server_req_params pvfs2_setparam_params; +extern struct PINT_server_req_params pvfs2_noop_params; +extern struct PINT_server_req_params pvfs2_unexpected_params; +extern struct PINT_server_req_params pvfs2_statfs_params; +extern struct PINT_server_req_params pvfs2_perf_update_params; +extern struct PINT_server_req_params pvfs2_job_timer_params; +extern struct PINT_server_req_params pvfs2_proto_error_params; +extern struct PINT_server_req_params pvfs2_perf_mon_params; +extern struct PINT_server_req_params pvfs2_event_mon_params; +extern struct PINT_server_req_params pvfs2_iterate_handles_params; +extern struct PINT_server_req_params pvfs2_get_eattr_params; +extern struct PINT_server_req_params pvfs2_get_eattr_list_params; +extern struct PINT_server_req_params pvfs2_set_eattr_params; +extern struct PINT_server_req_params pvfs2_set_eattr_list_params; +extern struct PINT_server_req_params pvfs2_del_eattr_params; +extern struct PINT_server_req_params pvfs2_list_eattr_params; + +/* table of incoming request types and associated parameters */ +struct PINT_server_req_entry PINT_server_req_table[] = +{ + /* 0 */ {PVFS_SERV_INVALID, NULL}, + /* 1 */ {PVFS_SERV_CREATE, &pvfs2_create_params}, + /* 2 */ {PVFS_SERV_REMOVE, &pvfs2_remove_params}, + /* 3 */ {PVFS_SERV_IO, &pvfs2_io_params}, + /* 4 */ {PVFS_SERV_GETATTR, &pvfs2_get_attr_params}, + /* 5 */ {PVFS_SERV_SETATTR, &pvfs2_set_attr_params}, + /* 6 */ {PVFS_SERV_LOOKUP_PATH, &pvfs2_lookup_params}, + /* 7 */ {PVFS_SERV_CRDIRENT, &pvfs2_crdirent_params}, + /* 8 */ {PVFS_SERV_RMDIRENT, &pvfs2_rmdirent_params}, + /* 9 */ {PVFS_SERV_CHDIRENT, &pvfs2_chdirent_params}, + /* 10 */ {PVFS_SERV_TRUNCATE, &pvfs2_truncate_params}, + /* 11 */ {PVFS_SERV_MKDIR, &pvfs2_mkdir_params}, + /* 12 */ {PVFS_SERV_READDIR, &pvfs2_readdir_params}, + /* 13 */ {PVFS_SERV_GETCONFIG, &pvfs2_get_config_params}, + /* 14 */ {PVFS_SERV_WRITE_COMPLETION, NULL}, + /* 15 */ {PVFS_SERV_FLUSH, &pvfs2_flush_params}, + /* 16 */ {PVFS_SERV_MGMT_SETPARAM, &pvfs2_setparam_params}, + /* 17 */ {PVFS_SERV_MGMT_NOOP, &pvfs2_noop_params}, + /* 18 */ {PVFS_SERV_STATFS, &pvfs2_statfs_params}, + /* 19 */ {PVFS_SERV_PERF_UPDATE, &pvfs2_perf_update_params}, + /* 20 */ {PVFS_SERV_MGMT_PERF_MON, &pvfs2_perf_mon_params}, + /* 21 */ {PVFS_SERV_MGMT_ITERATE_HANDLES, &pvfs2_iterate_handles_params}, + /* 22 */ {PVFS_SERV_MGMT_DSPACE_INFO_LIST, NULL}, + /* 23 */ {PVFS_SERV_MGMT_EVENT_MON, &pvfs2_event_mon_params}, + /* 24 */ {PVFS_SERV_MGMT_REMOVE_OBJECT, &pvfs2_mgmt_remove_object_params}, + /* 25 */ {PVFS_SERV_MGMT_REMOVE_DIRENT, &pvfs2_mgmt_remove_dirent_params}, + /* 26 */ {PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, &pvfs2_mgmt_get_dirdata_handle_params}, + /* 27 */ {PVFS_SERV_JOB_TIMER, &pvfs2_job_timer_params}, + /* 28 */ {PVFS_SERV_PROTO_ERROR, &pvfs2_proto_error_params}, + /* 29 */ {PVFS_SERV_GETEATTR, &pvfs2_get_eattr_params}, + /* 30 */ {PVFS_SERV_SETEATTR, &pvfs2_set_eattr_params}, + /* 31 */ {PVFS_SERV_DELEATTR, &pvfs2_del_eattr_params}, + /* 32 */ {PVFS_SERV_LISTEATTR, &pvfs2_list_eattr_params}, + /* 33 */ {PVFS_SERV_SMALL_IO, &pvfs2_small_io_params}, + /* 34 */ {PVFS_SERV_LISTATTR, &pvfs2_list_attr_params}, +}; + +inline int PINT_server_req_readonly(struct PVFS_server_req *req) +{ + return 1; +} + +inline int PINT_server_req_modify(struct PVFS_server_req *req) +{ + return 0; +} + +enum PINT_server_req_permissions +PINT_server_req_get_perms(struct PVFS_server_req *req) +{ + return PINT_server_req_table[req->op].params->perm; +} + +enum PINT_server_req_access_type +PINT_server_req_get_access_type(struct PVFS_server_req *req) +{ + if(!PINT_server_req_table[req->op].params->access_type) + { + return PINT_SERVER_REQ_READONLY; + } + return PINT_server_req_table[req->op].params->access_type(req); +} + +enum PINT_server_sched_policy +PINT_server_req_get_sched_policy(struct PVFS_server_req *req) +{ + return PINT_server_req_table[req->op].params->sched_policy; +} + +int PINT_server_req_get_object_ref( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + if(!PINT_server_req_table[req->op].params->get_object_ref) + { + *fs_id = 0; + *handle = 0; + return 0; + } + else + { + return PINT_server_req_table[req->op].params->get_object_ref( + req, fs_id, handle); + } +} + +/* + * PINT_map_server_op_to_string() + * + * provides a string representation of the server operation number + * + * returns a pointer to a static string (DONT FREE IT) on success, + * null on failure + */ +const char* PINT_map_server_op_to_string(enum PVFS_server_op op) +{ + const char *s = NULL; + + if (op >= 0 && op < PVFS_SERV_NUM_OPS) + s = PINT_server_req_table[op].params->string_name; + return s; +} + +/* + * Local variables: + * c-indent-level: 4 + * c-basic-offset: 4 + * End: + * + * vim: ts=8 sts=4 sw=4 expandtab + */ Index: src/server/pvfs2-server.c =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/pvfs2-server.c,v retrieving revision 1.248 diff -u -a -p -r1.248 pvfs2-server.c --- src/server/pvfs2-server.c 29 Jan 2008 16:16:54 -0000 1.248 +++ src/server/pvfs2-server.c 9 Feb 2008 21:58:50 -0000 @@ -160,255 +160,6 @@ static char *guess_alias(void); static TROVE_method_id trove_coll_to_method_callback(TROVE_coll_id); -/* table of incoming request types and associated parameters */ -struct PINT_server_req_params PINT_server_req_table[] = -{ - /* 0 */ - {PVFS_SERV_INVALID, - "invalid", - PINT_SERVER_CHECK_INVALID, - PINT_SERVER_ATTRIBS_REQUIRED, - NULL}, - - /* 1 */ - {PVFS_SERV_CREATE, - "create", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_create_sm}, - - /* 2 */ - {PVFS_SERV_REMOVE, - "remove", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_remove_sm}, - - /* 3 */ - {PVFS_SERV_IO, - "io", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_io_sm}, - - /* 4 */ - {PVFS_SERV_GETATTR, - "getattr", - PINT_SERVER_CHECK_ATTR, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_get_attr_sm}, - - /* 5 */ - {PVFS_SERV_SETATTR, - "setattr", - PINT_SERVER_CHECK_ATTR, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_set_attr_sm}, - - /* 6 */ - {PVFS_SERV_LOOKUP_PATH, - "lookup_path", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_lookup_sm}, - - /* 7 */ - {PVFS_SERV_CRDIRENT, - "crdirent", - PINT_SERVER_CHECK_CRDIRENT, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_crdirent_sm}, - - /* 8 */ - {PVFS_SERV_RMDIRENT, - "rmdirent", - PINT_SERVER_CHECK_WRITE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_rmdirent_sm}, - - /* 9 */ - {PVFS_SERV_CHDIRENT, - "chdirent", - PINT_SERVER_CHECK_WRITE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_chdirent_sm}, - - /* 10 */ - {PVFS_SERV_TRUNCATE, - "truncate", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_truncate_sm}, - - /* 11 */ - {PVFS_SERV_MKDIR, - "mkdir", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_mkdir_sm}, - - /* 12 */ - {PVFS_SERV_READDIR, - "readdir", - PINT_SERVER_CHECK_READ, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_readdir_sm}, - - /* 13 */ - {PVFS_SERV_GETCONFIG, - "getconfig", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_get_config_sm}, - - /* 14 */ - {PVFS_SERV_WRITE_COMPLETION, - "write_completion", - PINT_SERVER_CHECK_INVALID, - PINT_SERVER_ATTRIBS_REQUIRED, - NULL}, - - /* 15 */ - {PVFS_SERV_FLUSH, - "flush", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_flush_sm}, - - /* 16 */ - {PVFS_SERV_MGMT_SETPARAM, - "mgmt_setparam", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_setparam_sm}, - - /* 17 */ - {PVFS_SERV_MGMT_NOOP, - "mgmt_noop", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_noop_sm}, - - /* 18 */ - {PVFS_SERV_STATFS, - "statfs", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_statfs_sm}, - - /* 19 */ - {PVFS_SERV_PERF_UPDATE, - "perf_update", - PINT_SERVER_CHECK_INVALID, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_perf_update_sm}, - - /* 20 */ - {PVFS_SERV_MGMT_PERF_MON, - "mgmt_perf_mon", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_perf_mon_sm}, - - /* 21 */ - {PVFS_SERV_MGMT_ITERATE_HANDLES, - "mgmt_iterate_handles", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_iterate_handles_sm}, - - /* 22 */ - {PVFS_SERV_MGMT_DSPACE_INFO_LIST, - "mgmt_dspace_info_list", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - NULL}, - - /* 23 */ - {PVFS_SERV_MGMT_EVENT_MON, - "mgmt_event_mon", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_event_mon_sm}, - - /* 24 */ - {PVFS_SERV_MGMT_REMOVE_OBJECT, - "mgmt-remove-object", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_mgmt_remove_object_sm}, - - /* 25 */ - {PVFS_SERV_MGMT_REMOVE_DIRENT, - "mgmt-remove-dirent", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_mgmt_remove_dirent_sm}, - - /* 26 */ - {PVFS_SERV_MGMT_GET_DIRDATA_HANDLE, - "mgmt-get-dirdata-handle", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_mgmt_get_dirdata_handle_sm}, - - /* 27 */ - {PVFS_SERV_JOB_TIMER, - "job_timer", - PINT_SERVER_CHECK_INVALID, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_job_timer_sm}, - - /* 28 */ - {PVFS_SERV_PROTO_ERROR, - "proto_error", - PINT_SERVER_CHECK_INVALID, - PINT_SERVER_ATTRIBS_REQUIRED, - &pvfs2_proto_error_sm}, - - /* 29 */ - {PVFS_SERV_GETEATTR, - "geteattr", - PINT_SERVER_CHECK_ATTR, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_get_eattr_sm}, - - /* 30 */ - {PVFS_SERV_SETEATTR, - "seteattr", - PINT_SERVER_CHECK_ATTR, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_set_eattr_sm}, - - /* 31 */ - {PVFS_SERV_DELEATTR, - "deleattr", - PINT_SERVER_CHECK_ATTR, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_del_eattr_sm}, - - /* 32 */ - {PVFS_SERV_LISTEATTR, - "listeattr", - PINT_SERVER_CHECK_ATTR, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_list_eattr_sm}, - - /* 33 */ - {PVFS_SERV_SMALL_IO, - "small_io", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_small_io_sm}, - - /* 34 */ - {PVFS_SERV_LISTATTR, - "listattr", - PINT_SERVER_CHECK_NONE, - PINT_SERVER_ATTRIBS_NOT_REQUIRED, - &pvfs2_list_attr_sm}, -}; - struct server_configuration_s *PINT_get_server_config(void) { return &server_config; @@ -1969,7 +1720,7 @@ int server_state_machine_complete(PINT_s gossip_debug(GOSSIP_SERVER_DEBUG, "server_state_machine_complete %p\n",smcb); - + /* set a timestamp on the completion of the state machine */ id_gen_fast_register(&tmp_id, s_op); PINT_event_timestamp(PVFS_EVENT_API_SM, (int32_t)s_op->req->op, @@ -1981,10 +1732,12 @@ int server_state_machine_complete(PINT_s PINT_decode_release(&(s_op->decoded),PINT_DECODE_REQ); } + BMI_set_info(s_op->unexp_bmi_buff.addr, BMI_DEC_ADDR_REF, NULL); BMI_unexpected_free(s_op->unexp_bmi_buff.addr, s_op->unexp_bmi_buff.buffer); s_op->unexp_bmi_buff.buffer = NULL; + /* Remove s_op from the inprogress_sop_list */ qlist_del(&s_op->next); @@ -2028,7 +1781,7 @@ struct PINT_state_machine_s *server_op_s default : { if (op >= 0 && op < PVFS_SERV_NUM_OPS) - return PINT_server_req_table[op].sm; + return PINT_server_req_table[op].params->state_machine; else return NULL; break; @@ -2054,9 +1807,6 @@ void PINT_server_access_debug(PINT_serve const char * format, ...) { - PVFS_handle handle; - PVFS_fs_id fsid; - int flag; static char pint_access_buffer[GOSSIP_BUF_SIZE]; struct passwd* pw; struct group* gr; @@ -2068,7 +1818,6 @@ void PINT_server_access_debug(PINT_serve { va_start(ap, format); - PINT_req_sched_target_handle(s_op->req, 0, &handle, &fsid, &flag); pw = getpwuid(s_op->req->credentials.uid); gr = getgrgid(s_op->req->credentials.gid); snprintf(pint_access_buffer, GOSSIP_BUF_SIZE, @@ -2076,7 +1825,7 @@ void PINT_server_access_debug(PINT_serve ((pw) ? pw->pw_name : "UNKNOWN"), ((gr) ? gr->gr_name : "UNKNOWN"), BMI_addr_rev_lookup_unexpected(s_op->addr), - llu(handle), + llu(s_op->target_handle), s_op, PINT_map_server_op_to_string(s_op->req->op), format); @@ -2087,23 +1836,6 @@ void PINT_server_access_debug(PINT_serve } } #endif - -/* - * PINT_map_server_op_to_string() - * - * provides a string representation of the server operation number - * - * returns a pointer to a static string (DONT FREE IT) on success, - * null on failure - */ -const char* PINT_map_server_op_to_string(enum PVFS_server_op op) -{ - const char *s = NULL; - - if (op >= 0 && op < PVFS_SERV_NUM_OPS) - s = PINT_server_req_table[op].string_name; - return s; -} static char *guess_alias(void) { Index: src/server/pvfs2-server.h =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/pvfs2-server.h,v retrieving revision 1.147 diff -u -a -p -r1.147 pvfs2-server.h --- src/server/pvfs2-server.h 13 Apr 2007 05:14:30 -0000 1.147 +++ src/server/pvfs2-server.h 9 Feb 2008 21:58:50 -0000 @@ -76,30 +76,86 @@ enum PINT_server_req_permissions needs write and execute */ }; -/* indicates if the attributes for the target object must exist for - * the operation to proceed (see prelude.sm) - */ -enum PINT_server_req_attrib_flags +enum PINT_server_req_access_type { - PINT_SERVER_ATTRIBS_INVALID = 0, - PINT_SERVER_ATTRIBS_REQUIRED = 1, - /* operations that operate on datafiles or on incomplete metafiles - * do not expect to necessarily find attributes present before - * starting the operation - */ - PINT_SERVER_ATTRIBS_NOT_REQUIRED = 2 + PINT_SERVER_REQ_READONLY = 0, + PINT_SERVER_REQ_MODIFY }; +enum PINT_server_sched_policy +{ + PINT_SERVER_REQ_BYPASS = 0, + PINT_SERVER_REQ_SCHEDULE +}; + +#define PINT_GET_OBJECT_REF_DEFINE(req_name) \ +static inline int PINT_get_object_ref_##req_name( \ + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) \ +{ \ + *fs_id = req->u.req_name.fs_id; \ + *handle = req->u.req_name.handle; \ + return 0; \ +} + +typedef int (*PINT_server_req_access_callback)(struct PVFS_server_req *req); + +int PINT_server_req_readonly(struct PVFS_server_req *req); +int PINT_server_req_modify(struct PVFS_server_req *req); + struct PINT_server_req_params { - enum PVFS_server_op op_type; const char* string_name; + + /* For each request that specifies an object ref (fsid,handle) we + * get the common attributes on that object and check the permissions. + * For the request to proceed the permissions required by this flag + * must be met. + */ enum PINT_server_req_permissions perm; - enum PINT_server_req_attrib_flags attrib_flags; - struct PINT_state_machine_s* sm; + + /* Specifies the type of access on the object (readonly, modify). This + * is used by the request scheduler to determine + * which requests to queue (block), and which to schedule (proceed). + * This is a callback implemented by the request. For example, sometimes + * the io request writes, sometimes it reads. + * Default functions PINT_server_req_readonly and PINT_server_req_modify + * are used for requests that always require the same access type. + */ + PINT_server_req_access_callback access_type; + + /* Specifies the scheduling policy for the request. In some cases, + * we can bypass the request scheduler and proceed directly with the + * request. + */ + enum PINT_server_sched_policy sched_policy; + + /* A callback implemented by the request to return the object reference + * from the server request structure. + */ + int (*get_object_ref)( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle); + + /* The state machine that performs the request */ + struct PINT_state_machine_s *state_machine; }; -extern struct PINT_server_req_params PINT_server_req_table[]; +struct PINT_server_req_entry +{ + enum PVFS_server_op op_type; + struct PINT_server_req_params *params; +}; + +extern struct PINT_server_req_entry PINT_server_req_table[]; + +int PINT_server_req_get_object_ref( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle); + +enum PINT_server_req_permissions +PINT_server_req_get_perms(struct PVFS_server_req *req); +enum PINT_server_req_access_type +PINT_server_req_get_access_type(struct PVFS_server_req *req); +enum PINT_server_sched_policy +PINT_server_req_get_sched_policy(struct PVFS_server_req *req); const char* PINT_map_server_op_to_string(enum PVFS_server_op op); @@ -363,6 +419,9 @@ typedef struct PINT_server_op PVFS_fs_id target_fs_id; PVFS_object_attr *target_object_attr; + enum PINT_server_req_access_type access_type; + enum PINT_server_sched_policy sched_policy; + union { /* request-specific scratch spaces for use during processing */ @@ -404,51 +463,16 @@ void PINT_server_access_debug(PINT_serve int64_t debug_mask, const char * format, ...) __attribute__((format(printf, 3, 4))); -/* server operation state machines */ -extern struct PINT_state_machine_s pvfs2_get_config_sm; -extern struct PINT_state_machine_s pvfs2_get_attr_sm; -extern struct PINT_state_machine_s pvfs2_list_attr_sm; -extern struct PINT_state_machine_s pvfs2_set_attr_sm; -extern struct PINT_state_machine_s pvfs2_create_sm; -extern struct PINT_state_machine_s pvfs2_crdirent_sm; -extern struct PINT_state_machine_s pvfs2_mkdir_sm; -extern struct PINT_state_machine_s pvfs2_readdir_sm; -extern struct PINT_state_machine_s pvfs2_lookup_sm; -extern struct PINT_state_machine_s pvfs2_io_sm; -extern struct PINT_state_machine_s pvfs2_small_io_sm; -extern struct PINT_state_machine_s pvfs2_remove_sm; -extern struct PINT_state_machine_s pvfs2_mgmt_remove_object_sm; -extern struct PINT_state_machine_s pvfs2_mgmt_remove_dirent_sm; -extern struct PINT_state_machine_s pvfs2_mgmt_get_dirdata_handle_sm; -extern struct PINT_state_machine_s pvfs2_rmdirent_sm; -extern struct PINT_state_machine_s pvfs2_chdirent_sm; -extern struct PINT_state_machine_s pvfs2_flush_sm; -extern struct PINT_state_machine_s pvfs2_truncate_sm; -extern struct PINT_state_machine_s pvfs2_setparam_sm; -extern struct PINT_state_machine_s pvfs2_noop_sm; -extern struct PINT_state_machine_s pvfs2_unexpected_sm; -extern struct PINT_state_machine_s pvfs2_statfs_sm; -extern struct PINT_state_machine_s pvfs2_perf_update_sm; -extern struct PINT_state_machine_s pvfs2_job_timer_sm; -extern struct PINT_state_machine_s pvfs2_proto_error_sm; -extern struct PINT_state_machine_s pvfs2_perf_mon_sm; -extern struct PINT_state_machine_s pvfs2_event_mon_sm; -extern struct PINT_state_machine_s pvfs2_iterate_handles_sm; -extern struct PINT_state_machine_s pvfs2_get_eattr_sm; -extern struct PINT_state_machine_s pvfs2_get_eattr_list_sm; -extern struct PINT_state_machine_s pvfs2_set_eattr_sm; -extern struct PINT_state_machine_s pvfs2_set_eattr_list_sm; -extern struct PINT_state_machine_s pvfs2_del_eattr_sm; -extern struct PINT_state_machine_s pvfs2_list_eattr_sm; -extern struct PINT_state_machine_s pvfs2_list_eattr_list_sm; /* nested state machines */ extern struct PINT_state_machine_s pvfs2_get_attr_work_sm; extern struct PINT_state_machine_s pvfs2_prelude_sm; +extern struct PINT_state_machine_s pvfs2_prelude_work_sm; extern struct PINT_state_machine_s pvfs2_final_response_sm; extern struct PINT_state_machine_s pvfs2_check_entry_not_exist_sm; extern struct PINT_state_machine_s pvfs2_remove_work_sm; extern struct PINT_state_machine_s pvfs2_mkdir_work_sm; +extern struct PINT_state_machine_s pvfs2_unexpected_sm; /* Exported Prototypes */ struct server_configuration_s *get_server_config_struct(void); @@ -474,7 +498,7 @@ int server_state_machine_start_noreq( #define PINT_OP_STATE PINT_server_op #define PINT_OP_STATE_GET_MACHINE(_op) \ ((_op >= 0 && _op < PVFS_SERV_NUM_OPS) ? \ - PINT_server_req_table[_op].sm : NULL) + PINT_server_req_table[_op].params->sm : NULL) #endif #include "pvfs2-internal.h" Index: src/server/readdir.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/readdir.sm,v retrieving revision 1.51 diff -u -a -p -r1.51 readdir.sm --- src/server/readdir.sm 30 Aug 2007 00:13:44 -0000 1.51 +++ src/server/readdir.sm 9 Feb 2008 21:58:50 -0000 @@ -257,6 +257,16 @@ static PINT_sm_action readdir_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(readdir); + +struct PINT_server_req_params pvfs2_readdir_params = +{ + .string_name = "readdir", + .perm = PINT_SERVER_CHECK_READ, + .get_object_ref = PINT_get_object_ref_readdir, + .state_machine = &pvfs2_readdir_sm +}; + /* * Local variables: * mode: c Index: src/server/remove.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/remove.sm,v retrieving revision 1.59 diff -u -a -p -r1.59 remove.sm --- src/server/remove.sm 7 Dec 2007 23:08:46 -0000 1.59 +++ src/server/remove.sm 9 Feb 2008 21:58:50 -0000 @@ -384,6 +384,18 @@ static PINT_sm_action remove_setup_work( return SM_ACTION_COMPLETE; } +PINT_GET_OBJECT_REF_DEFINE(remove); + +struct PINT_server_req_params pvfs2_remove_params = +{ + .string_name = "remove", + .get_object_ref = PINT_get_object_ref_remove, + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .state_machine = &pvfs2_remove_sm +}; + /* * Local variables: Index: src/server/rmdirent.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/rmdirent.sm,v retrieving revision 1.55 diff -u -a -p -r1.55 rmdirent.sm --- src/server/rmdirent.sm 30 Aug 2007 00:13:44 -0000 1.55 +++ src/server/rmdirent.sm 9 Feb 2008 21:58:50 -0000 @@ -108,7 +108,7 @@ static int rmdirent_verify_parent_metada " reading dirdata handle (coll_id = 0x%x, handle = %llu, " "key = %s (%d), val_buf = %p (%d))\n", s_op->req->u.rmdirent.fs_id, - llu(s_op->req->u.rmdirent.parent_handle), + llu(s_op->req->u.rmdirent.handle), (char *)s_op->key.buffer, s_op->key.buffer_sz, s_op->val.buffer, @@ -116,7 +116,7 @@ static int rmdirent_verify_parent_metada ret = job_trove_keyval_read( s_op->req->u.rmdirent.fs_id, - s_op->req->u.rmdirent.parent_handle, + s_op->req->u.rmdirent.handle, &s_op->key, &s_op->val, 0, @@ -216,7 +216,7 @@ static PINT_sm_action rmdirent_update_di PVFS_object_attr_to_ds_attr(tmp_attr_ptr, ds_attr); ret = job_trove_dspace_setattr( - s_op->req->u.rmdirent.fs_id, s_op->req->u.rmdirent.parent_handle, + s_op->req->u.rmdirent.fs_id, s_op->req->u.rmdirent.handle, ds_attr, TROVE_SYNC, smcb, 0, js_p, &j_id, server_job_context); @@ -289,6 +289,18 @@ static PINT_sm_action rmdirent_cleanup( { return(server_state_machine_complete(smcb)); } + +PINT_GET_OBJECT_REF_DEFINE(rmdirent); + +struct PINT_server_req_params pvfs2_rmdirent_params = +{ + .string_name = "rmdirent", + .perm = PINT_SERVER_CHECK_WRITE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_rmdirent, + .state_machine = &pvfs2_rmdirent_sm +}; /* * Local variables: Index: src/server/set-attr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/set-attr.sm,v retrieving revision 1.72 diff -u -a -p -r1.72 set-attr.sm --- src/server/set-attr.sm 30 Aug 2007 00:13:44 -0000 1.72 +++ src/server/set-attr.sm 9 Feb 2008 21:58:50 -0000 @@ -486,6 +486,18 @@ static PINT_sm_action setattr_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(setattr); + +struct PINT_server_req_params pvfs2_set_attr_params = +{ + .string_name = "setattr", + .perm = PINT_SERVER_CHECK_ATTR, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_setattr, + .state_machine = &pvfs2_set_attr_sm +}; + /* * Local variables: * mode: c Index: src/server/set-eattr.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/set-eattr.sm,v retrieving revision 1.19 diff -u -a -p -r1.19 set-eattr.sm --- src/server/set-eattr.sm 30 Aug 2007 00:13:44 -0000 1.19 +++ src/server/set-eattr.sm 9 Feb 2008 21:58:50 -0000 @@ -165,6 +165,18 @@ static int seteattr_cleanup( return(server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(seteattr); + +struct PINT_server_req_params pvfs2_set_eattr_params = +{ + .string_name = "set_eattr", + .perm = PINT_SERVER_CHECK_ATTR, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_seteattr, + .state_machine = &pvfs2_set_eattr_sm +}; + /* * Local variables: * mode: c Index: src/server/setparam.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/setparam.sm,v retrieving revision 1.33 diff -u -a -p -r1.33 setparam.sm --- src/server/setparam.sm 30 Aug 2007 00:13:44 -0000 1.33 +++ src/server/setparam.sm 9 Feb 2008 21:58:50 -0000 @@ -15,6 +15,7 @@ #include "pvfs2-server.h" #include "pint-event.h" #include "pvfs2-internal.h" +#include "request-scheduler/request-scheduler.h" static int check_fs_id(PVFS_fs_id fs_id); @@ -154,9 +155,14 @@ static PINT_sm_action setparam_work( js_p->error_code = 0; return SM_ACTION_COMPLETE; case PVFS_SERV_PARAM_MODE: - /* no work to do here; request scheduler has already handled */ + + s_op->resp.u.mgmt_setparam.old_value = PINT_req_sched_get_mode(); + ret = job_req_sched_change_mode(s_op->req->u.mgmt_setparam.value, + NULL, 0, js_p, &s_op->scheduled_id, + server_job_context); + js_p->error_code = 0; - return SM_ACTION_COMPLETE; + return ret; } gossip_lerr("Error: mgmt_setparam for unknown parameter %d.\n", @@ -239,6 +245,24 @@ check_failed: return ret; } + +static inline int PINT_get_object_ref_setparam( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = req->u.mgmt_setparam.fs_id; + *handle = PVFS_HANDLE_NULL; + return 0; +}; + +struct PINT_server_req_params pvfs2_setparam_params = +{ + .string_name = "mgmt_setparam", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_setparam, + .state_machine = &pvfs2_setparam_sm +}; /* * Local variables: Index: src/server/small-io.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/small-io.sm,v retrieving revision 1.19 diff -u -a -p -r1.19 small-io.sm --- src/server/small-io.sm 30 Aug 2007 00:13:45 -0000 1.19 +++ src/server/small-io.sm 9 Feb 2008 21:58:50 -0000 @@ -241,6 +241,28 @@ static PINT_sm_action small_io_cleanup( return server_state_machine_complete(smcb); } +static inline int PINT_server_req_access_small_io( + struct PVFS_server_req *req) +{ + if(req->u.io.io_type == PVFS_IO_READ) + { + return 1; + } + return 0; +} + +PINT_GET_OBJECT_REF_DEFINE(small_io); + +struct PINT_server_req_params pvfs2_small_io_params = +{ + .string_name = "small_io", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_access_small_io, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_small_io, + .state_machine = &pvfs2_small_io_sm +}; + /* * Local variables: * mode: c Index: src/server/statfs.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/statfs.sm,v retrieving revision 1.16 diff -u -a -p -r1.16 statfs.sm --- src/server/statfs.sm 30 Aug 2007 00:13:45 -0000 1.16 +++ src/server/statfs.sm 9 Feb 2008 21:58:50 -0000 @@ -146,6 +146,21 @@ static PINT_sm_action statfs_cleanup( return(server_state_machine_complete(smcb)); } +static inline int PINT_get_object_ref_statfs( + struct PVFS_server_req *req, PVFS_fs_id *fs_id, PVFS_handle *handle) +{ + *fs_id = req->u.statfs.fs_id; + *handle = PVFS_HANDLE_NULL; + return 0; +} + +struct PINT_server_req_params pvfs2_statfs_params = +{ + .string_name = "statfs", + .get_object_ref = PINT_get_object_ref_statfs, + .state_machine = &pvfs2_statfs_sm +}; + /* * Local variables: Index: src/server/truncate.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/truncate.sm,v retrieving revision 1.8 diff -u -a -p -r1.8 truncate.sm --- src/server/truncate.sm 30 Aug 2007 00:13:45 -0000 1.8 +++ src/server/truncate.sm 9 Feb 2008 21:58:50 -0000 @@ -79,6 +79,18 @@ static PINT_sm_action truncate_cleanup( return (server_state_machine_complete(smcb)); } +PINT_GET_OBJECT_REF_DEFINE(truncate); + +struct PINT_server_req_params pvfs2_truncate_params = +{ + .string_name = "truncate", + .perm = PINT_SERVER_CHECK_NONE, + .access_type = PINT_server_req_modify, + .sched_policy = PINT_SERVER_REQ_SCHEDULE, + .get_object_ref = PINT_get_object_ref_truncate, + .state_machine = &pvfs2_truncate_sm +}; + /* * Local variables: * mode: c Index: src/server/unexpected.sm =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/unexpected.sm,v retrieving revision 1.3 diff -u -a -p -r1.3 unexpected.sm --- src/server/unexpected.sm 30 Aug 2007 00:13:45 -0000 1.3 +++ src/server/unexpected.sm 9 Feb 2008 21:58:50 -0000 @@ -99,6 +99,10 @@ static PINT_sm_action unexpected_map( */ gossip_lerr("Error: post unexpected failure when restarting.\n"); } + + /* Bump up the reference count on the bmi address that we are using */ + BMI_set_info(s_op->unexp_bmi_buff.addr, BMI_INC_ADDR_REF, NULL); + /* restart as new request state machine */ memset(js_p, 0, sizeof(job_status_s)); ret = server_state_machine_start(smcb, js_p); Index: src/server/request-scheduler/request-scheduler.c =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/request-scheduler/request-scheduler.c,v retrieving revision 1.65 diff -u -a -p -r1.65 request-scheduler.c --- src/server/request-scheduler/request-scheduler.c 20 Sep 2006 04:36:15 -0000 1.65 +++ src/server/request-scheduler/request-scheduler.c 9 Feb 2008 21:58:50 -0000 @@ -73,8 +73,8 @@ struct req_sched_list /** linked list elements; one for each request in the scheduler */ struct req_sched_element { + enum PVFS_server_op op; struct qlist_head list_link; /* ties it to a queue */ - struct PVFS_server_req *req_ptr; /* ties it to a request */ struct qlist_head ready_link; /* ties to ready queue */ void *user_ptr; /* user pointer */ req_sched_id id; /* unique identifier */ @@ -83,6 +83,9 @@ struct req_sched_element PVFS_handle handle; struct timeval tv; /* used for timer events */ int readonly_flag; /* indicates a read only operation */ + + int mode_change; /* specifies that the element is a mode change */ + enum PVFS_server_mode mode; /* the mode to change to */ }; @@ -189,169 +192,110 @@ int PINT_req_sched_finalize( return (0); } -/** Finds the handle that the given request will operate on - * - * \return 0 on success, -errno on failure - * - * \note a handle value of 0 and a return value of 0 indicates - * that the request does not operate on any particular handle - * - * \note a return value of 1 indicates that we can let this operation pass - * through without any scheduling - * - * \todo we need to fix this function and all of its callers if we - * define something besides "0" to represent an invalid handle value - */ -int PINT_req_sched_target_handle( - struct PVFS_server_req *req, - int req_index, - PVFS_handle * handle, - PVFS_fs_id * fs_id, - int* readonly_flag) +int PINT_req_sched_change_mode(enum PVFS_server_mode mode, + void *user_ptr, + req_sched_id *id) { - *handle = 0; - *fs_id = 0; - *readonly_flag = 1; + int ret = -1; + int mode_change_ready = 0; + struct req_sched_element *mode_element; - switch (req->op) + /* create a structure to store in the request queues */ + mode_element = (struct req_sched_element *) malloc( + sizeof(struct req_sched_element)); + if (!mode_element) { - case PVFS_SERV_INVALID: - return (-EINVAL); - case PVFS_SERV_MGMT_SETPARAM: - return (1); - case PVFS_SERV_CREATE: - *readonly_flag = 0; - return (1); - case PVFS_SERV_REMOVE: - *readonly_flag = 0; - *handle = req->u.remove.handle; - *fs_id = req->u.remove.fs_id; - return (0); - case PVFS_SERV_MGMT_REMOVE_OBJECT: - *readonly_flag = 0; - *handle = req->u.mgmt_remove_object.handle; - *fs_id = req->u.mgmt_remove_object.fs_id; - return (0); - case PVFS_SERV_MGMT_REMOVE_DIRENT: - *readonly_flag = 0; - *handle = req->u.mgmt_remove_dirent.handle; - *fs_id = req->u.mgmt_remove_dirent.fs_id; - return (0); - case PVFS_SERV_IO: - if(req->u.io.io_type == PVFS_IO_WRITE) - *readonly_flag = 0; - *handle = req->u.io.handle; - *fs_id = req->u.io.fs_id; - return (0); - case PVFS_SERV_SMALL_IO: - if(req->u.small_io.io_type == PVFS_IO_WRITE) - *readonly_flag = 0; - *handle = req->u.small_io.handle; - *fs_id = req->u.small_io.fs_id; - return (0); - case PVFS_SERV_GETATTR: - *handle = req->u.getattr.handle; - *fs_id = req->u.getattr.fs_id; - return (0); - case PVFS_SERV_SETATTR: - *readonly_flag = 0; - *handle = req->u.setattr.handle; - *fs_id = req->u.setattr.fs_id; - return (0); - case PVFS_SERV_LOOKUP_PATH: - *handle = req->u.lookup_path.starting_handle; - *fs_id = req->u.lookup_path.fs_id; - return (0); - case PVFS_SERV_CRDIRENT: - *readonly_flag = 0; - *handle = req->u.crdirent.parent_handle; - *fs_id = req->u.crdirent.fs_id; - return (0); - case PVFS_SERV_RMDIRENT: - *readonly_flag = 0; - *handle = req->u.rmdirent.parent_handle; - *fs_id = req->u.rmdirent.fs_id; - return (0); - case PVFS_SERV_CHDIRENT: - *readonly_flag = 0; - *handle = req->u.chdirent.parent_handle; - *fs_id = req->u.chdirent.fs_id; - return (0); - case PVFS_SERV_TRUNCATE: - *readonly_flag = 0; - *handle = req->u.truncate.handle; - *fs_id = req->u.truncate.fs_id; - return (0); - case PVFS_SERV_MKDIR: - *readonly_flag = 0; - return (1); - case PVFS_SERV_READDIR: - *handle = req->u.readdir.handle; - *fs_id = req->u.readdir.fs_id; - return (0); - case PVFS_SERV_GETCONFIG: - return (1); - case PVFS_SERV_FLUSH: - *readonly_flag = 0; - *handle = req->u.flush.handle; - *fs_id = req->u.flush.fs_id; - return (0); - case PVFS_SERV_LISTATTR: - *readonly_flag = 1; - *fs_id = req->u.listattr.fs_id; - *handle = PVFS_HANDLE_NULL; - return 0; - case PVFS_SERV_MGMT_NOOP: - return (1); - case PVFS_SERV_MGMT_PERF_MON: - return (1); - case PVFS_SERV_MGMT_EVENT_MON: - return (1); - case PVFS_SERV_MGMT_ITERATE_HANDLES: - *fs_id = req->u.mgmt_iterate_handles.fs_id; - return (1); - case PVFS_SERV_MGMT_DSPACE_INFO_LIST: - if(req_index >= req->u.mgmt_dspace_info_list.handle_count) + return (-errno); + } + + mode_element->user_ptr = user_ptr; + id_gen_fast_register(id, mode_element); + mode_element->id = *id; + mode_element->state = REQ_QUEUED; + mode_element->mode_change = 1; + mode_element->mode = mode; + + /* will this be the front of the queue */ + if(qlist_empty(&mode_queue)) + mode_change_ready = 1; + + qlist_add_tail(&(mode_element->list_link), &mode_queue); + if(mode_change_ready) + { + if(mode == PVFS_SERVER_NORMAL_MODE) { - return(-EOVERFLOW); + /* let this go through regardless */ + ret = 1; + mode_element->state = REQ_SCHEDULED; + current_mode = mode; } - *handle = req->u.mgmt_dspace_info_list.handle_array[req_index]; - *fs_id = req->u.mgmt_dspace_info_list.fs_id; - return (0); - case PVFS_SERV_MGMT_GET_DIRDATA_HANDLE: - *handle = req->u.mgmt_get_dirdata_handle.handle; - *fs_id = req->u.mgmt_get_dirdata_handle.fs_id; - return (0); - case PVFS_SERV_GETEATTR: - *handle = req->u.geteattr.handle; - *fs_id = req->u.geteattr.fs_id; - return (0); - case PVFS_SERV_SETEATTR: - *readonly_flag = 0; - *handle = req->u.seteattr.handle; - *fs_id = req->u.seteattr.fs_id; - return (0); - case PVFS_SERV_DELEATTR: - *readonly_flag = 0; - *handle = req->u.deleattr.handle; - *fs_id = req->u.deleattr.fs_id; - return (0); - case PVFS_SERV_LISTEATTR: - *handle = req->u.listeattr.handle; - *fs_id = req->u.listeattr.fs_id; - return (0); - case PVFS_SERV_STATFS: - *fs_id = req->u.statfs.fs_id; - return (1); - case PVFS_SERV_WRITE_COMPLETION: - case PVFS_SERV_PERF_UPDATE: - case PVFS_SERV_JOB_TIMER: - case PVFS_SERV_PROTO_ERROR: - case PVFS_SERV_NUM_OPS: /* sentinel */ - /* these should never show up here */ - return (-EINVAL); + else if(mode == PVFS_SERVER_ADMIN_MODE) + { + assert(sched_count > -1); + /* for this to work, we must wait for pending ops to complete */ + if(sched_count == 0) + { + ret = 1; + mode_element->state = REQ_SCHEDULED; + current_mode = mode; + } + else + { + ret = 0; + mode_element->state = REQ_QUEUED; + } + } + else + { + /* TODO: be nicer about this */ + assert(0); + } + return(ret); + } + else + { + mode_element->state = REQ_QUEUED; + return(0); + } +} + +static int PINT_req_sched_in_admin_mode(void) +{ + struct req_sched_element *mode_element = NULL; + if(!qlist_empty(&mode_queue)) + mode_element = qlist_entry(mode_queue.next, struct req_sched_element, + list_link); + if(current_mode == PVFS_SERVER_ADMIN_MODE || + (mode_element && mode_element->mode == PVFS_SERVER_ADMIN_MODE)) + { + return 1; + } + return 0; +} + +static int PINT_req_sched_schedule_mode_change(void) +{ + struct req_sched_element *next_element; + + /* prepare to schedule mode change if we can */ + /* NOTE: only transitions to admin mode are ever queued */ + if(sched_count == 0 && !qlist_empty(&mode_queue)) + { + next_element = qlist_entry(mode_queue.next, struct req_sched_element, + list_link); + next_element->state = REQ_READY_TO_SCHEDULE; + qlist_add_tail(&next_element->ready_link, &ready_queue); + } + return 0; +} + +static void PINT_req_sched_do_change_mode( + struct req_sched_element *req_sched_element) +{ + if(req_sched_element->mode_change) + { + current_mode = req_sched_element->mode; } - return (0); } /* scheduler submission */ @@ -362,48 +306,34 @@ int PINT_req_sched_target_handle( * request will be scheduled later, and -errno on failure */ int PINT_req_sched_post( - struct PVFS_server_req *in_request, - int req_index, + enum PVFS_server_op op, + PVFS_fs_id fs_id, + PVFS_handle handle, + int readonly_flag, + int schedule, void *in_user_ptr, req_sched_id * out_id) { struct qlist_head *hash_link; - PVFS_handle handle; int ret = -1; struct req_sched_element *tmp_element; struct req_sched_element *tmp_element2; struct req_sched_list *tmp_list; struct req_sched_element *next_element; struct req_sched_element *last_element; - struct req_sched_element *mode_element = NULL; - PVFS_fs_id fs_id; - enum PVFS_server_mode target_mode; - int mode_change_ready = 0; - int readonly_flag = 0; struct qlist_head *iterator; int tmp_flag; - /* find the handle */ - ret = PINT_req_sched_target_handle(in_request, req_index, &handle, &fs_id, - &readonly_flag); - if (ret < 0) + if(!schedule) { - return (ret); - } - if(ret == 1) - { - if(!readonly_flag && !PVFS_SERV_IS_MGMT_OP(in_request->op)) + if(!readonly_flag && !PVFS_SERV_IS_MGMT_OP(op)) { /* if this requests modifies the file system, we have to check * to see if we are in admin mode or about to enter admin mode */ - if(!qlist_empty(&mode_queue)) - mode_element = qlist_entry(mode_queue.next, struct req_sched_element, - list_link); - if(current_mode == PVFS_SERVER_ADMIN_MODE || (mode_element - && mode_element->req_ptr->u.mgmt_setparam.value == PVFS_SERVER_ADMIN_MODE)) + if(PINT_req_sched_in_admin_mode()) { - return(-PVFS_EAGAIN); + return (-PVFS_EAGAIN); } } @@ -425,7 +355,7 @@ int PINT_req_sched_post( return (-errno); } - tmp_element->req_ptr = in_request; + tmp_element->op = op; tmp_element->user_ptr = in_user_ptr; id_gen_fast_register(out_id, tmp_element); tmp_element->id = *out_id; @@ -434,69 +364,13 @@ int PINT_req_sched_post( tmp_element->list_head = NULL; tmp_element->readonly_flag = readonly_flag; - /* is this a request to change the server's operating mode? */ - if(in_request->op == PVFS_SERV_MGMT_SETPARAM - && in_request->u.mgmt_setparam.param == PVFS_SERV_PARAM_MODE) - { - target_mode = (enum PVFS_server_mode)in_request->u.mgmt_setparam.value; - /* will this be the front of the queue */ - if(qlist_empty(&mode_queue)) - mode_change_ready = 1; - - qlist_add_tail(&(tmp_element->list_link), &mode_queue); - if(mode_change_ready) - { - if(target_mode == PVFS_SERVER_NORMAL_MODE) - { - /* let this go through regardless */ - ret = 1; - tmp_element->state = REQ_SCHEDULED; - current_mode = target_mode; - } - else if(target_mode == PVFS_SERVER_ADMIN_MODE) - { - assert(sched_count > -1); - /* for this to work, we must wait for pending ops to complete */ - if(sched_count == 0) - { - ret = 1; - tmp_element->state = REQ_SCHEDULED; - current_mode = target_mode; - } - else - { - ret = 0; - tmp_element->state = REQ_QUEUED; - } - } - else - { - /* TODO: be nicer about this */ - assert(0); - } - return(ret); - } - else - { - tmp_element->state = REQ_QUEUED; - return(0); - } - } - - if(!readonly_flag && !PVFS_SERV_IS_MGMT_OP(in_request->op)) + if(!readonly_flag && !PVFS_SERV_IS_MGMT_OP(op)) { - /* if this requests modifies the file system, we have to check - * to see if we are in admin mode or about to enter admin mode - */ - if(!qlist_empty(&mode_queue)) - mode_element = qlist_entry(mode_queue.next, struct req_sched_element, - list_link); - if(current_mode == PVFS_SERVER_ADMIN_MODE || (mode_element - && mode_element->req_ptr->u.mgmt_setparam.value == PVFS_SERVER_ADMIN_MODE)) - { - free(tmp_element); - return(-PVFS_EAGAIN); - } + if(PINT_req_sched_in_admin_mode()) + { + free(tmp_element); + return(-PVFS_EAGAIN); + } } /* see if we have a request queue up for this handle */ @@ -545,7 +419,7 @@ int PINT_req_sched_post( last_element = qlist_entry((tmp_list->req_list.prev), struct req_sched_element, list_link); - if (in_request->op == PVFS_SERV_IO && + if (op == PVFS_SERV_IO && next_element->state == REQ_SCHEDULED && last_element->state == REQ_SCHEDULED) { @@ -558,7 +432,7 @@ int PINT_req_sched_post( { tmp_element2 = qlist_entry(iterator, struct req_sched_element, list_link); - if(tmp_element2->req_ptr->op != PVFS_SERV_IO) + if(tmp_element2->op != PVFS_SERV_IO) { tmp_flag = 1; break; @@ -611,8 +485,7 @@ int PINT_req_sched_post( ret = 0; } } - else if((in_request->op == PVFS_SERV_CRDIRENT || - in_request->op == PVFS_SERV_RMDIRENT) && + else if((op == PVFS_SERV_CRDIRENT || op == PVFS_SERV_RMDIRENT) && next_element->state == REQ_SCHEDULED && last_element->state == REQ_SCHEDULED) { @@ -682,7 +555,6 @@ int PINT_req_sched_post_timer( return (-errno); } - tmp_element->req_ptr = NULL; tmp_element->user_ptr = in_user_ptr; id_gen_fast_register(out_id, tmp_element); tmp_element->id = *out_id; @@ -806,7 +678,7 @@ int PINT_req_sched_unpost( /* keep going as long as the operations are I/O requests; * we let these all go concurrently */ - while (next_element && next_element->req_ptr->op == PVFS_SERV_IO + while (next_element && next_element->op == PVFS_SERV_IO && next_element->list_link.next != &(tmp_element->list_head->req_list)) { @@ -815,7 +687,7 @@ int PINT_req_sched_unpost( struct req_sched_element, list_link); if (next_element - && next_element->req_ptr->op == PVFS_SERV_IO) + && next_element->op == PVFS_SERV_IO) { gossip_debug( GOSSIP_REQ_SCHED_DEBUG, "REQ SCHED " @@ -835,15 +707,7 @@ int PINT_req_sched_unpost( /* destroy the unposted element */ free(tmp_element); - /* prepare to schedule mode change if we can */ - /* NOTE: only transitions to admin mode are ever queued */ - if(sched_count == 0 && !qlist_empty(&mode_queue)) - { - next_element = qlist_entry(mode_queue.next, struct req_sched_element, - list_link); - next_element->state = REQ_READY_TO_SCHEDULE; - qlist_add_tail(&next_element->ready_link, &ready_queue); - } + PINT_req_sched_schedule_mode_change(); return (0); } @@ -916,13 +780,13 @@ int PINT_req_sched_release( next_element->state = REQ_READY_TO_SCHEDULE; qlist_add_tail(&(next_element->ready_link), &ready_queue); - if(next_element->req_ptr->op == PVFS_SERV_IO) + if(next_element->op == PVFS_SERV_IO) { /* keep going as long as the operations are I/O requests; * we let these all go concurrently */ while (next_element && - (next_element->req_ptr->op == PVFS_SERV_IO) && + (next_element->op == PVFS_SERV_IO) && (next_element->list_link.next != &(tmp_list->req_list))) { next_element = @@ -930,7 +794,7 @@ int PINT_req_sched_release( struct req_sched_element, list_link); if (next_element && - (next_element->req_ptr->op == PVFS_SERV_IO)) + (next_element->op == PVFS_SERV_IO)) { gossip_debug( GOSSIP_REQ_SCHED_DEBUG, @@ -982,16 +846,7 @@ int PINT_req_sched_release( /* destroy the released request element */ free(tmp_element); - /* prepare to schedule mode change if we can */ - /* NOTE: only transitions to admin mode are ever queued */ - if(sched_count == 0 && !qlist_empty(&mode_queue)) - { - next_element = qlist_entry(mode_queue.next, struct req_sched_element, - list_link); - next_element->state = REQ_READY_TO_SCHEDULE; - qlist_add_tail(&next_element->ready_link, &ready_queue); - } - + PINT_req_sched_schedule_mode_change(); return (1); } @@ -1042,14 +897,8 @@ int PINT_req_sched_test( "handle: %llu, queue_element: %p\n", llu(tmp_element->handle), tmp_element); - /* if this is a mode change, then transition now */ - if ((tmp_element->req_ptr->op == PVFS_SERV_MGMT_SETPARAM) && - (tmp_element->req_ptr->u.mgmt_setparam.param == - PVFS_SERV_PARAM_MODE)) - { - current_mode = tmp_element->req_ptr->u.mgmt_setparam.value; - } - return (1); + PINT_req_sched_do_change_mode(tmp_element); + return (1); } else if (tmp_element->state == REQ_TIMING) { @@ -1142,13 +991,7 @@ int PINT_req_sched_testsome( "REQ SCHED SCHEDULING, handle: %llu, " "queue_element: %p\n", llu(tmp_element->handle), tmp_element); - /* if this is a mode change, then transition now */ - if(tmp_element->req_ptr->op == PVFS_SERV_MGMT_SETPARAM && - tmp_element->req_ptr->u.mgmt_setparam.param == PVFS_SERV_PARAM_MODE) - { - current_mode = tmp_element->req_ptr->u.mgmt_setparam.value; - } - + PINT_req_sched_do_change_mode(tmp_element); } else if(tmp_element->state == REQ_TIMING) { @@ -1255,12 +1098,7 @@ int PINT_req_sched_testworld( "REQ SCHED SCHEDULING, " "handle: %llu, queue_element: %p\n", llu(tmp_element->handle), tmp_element); - /* if this is a mode change, then transition now */ - if(tmp_element->req_ptr->op == PVFS_SERV_MGMT_SETPARAM && - tmp_element->req_ptr->u.mgmt_setparam.param == PVFS_SERV_PARAM_MODE) - { - current_mode = tmp_element->req_ptr->u.mgmt_setparam.value; - } + PINT_req_sched_do_change_mode(tmp_element); } if (*inout_count_p > 0) return (1); Index: src/server/request-scheduler/request-scheduler.h =================================================================== RCS file: /projects/cvsroot/pvfs2/src/server/request-scheduler/request-scheduler.h,v retrieving revision 1.15 diff -u -a -p -r1.15 request-scheduler.h --- src/server/request-scheduler/request-scheduler.h 13 Jan 2005 18:42:28 -0000 1.15 +++ src/server/request-scheduler/request-scheduler.h 9 Feb 2008 21:58:50 -0000 @@ -33,18 +33,21 @@ int PINT_req_sched_finalize( void); /* retrieving information about incoming requests */ -int PINT_req_sched_target_handle(struct PVFS_server_req *req, - int req_index, - PVFS_handle * handle, - PVFS_fs_id * fs_id, - int* readonly_flag); - /* scheduler submission */ -int PINT_req_sched_post(struct PVFS_server_req *in_request, - int req_index, +int PINT_req_sched_post(enum PVFS_server_op op, + PVFS_fs_id fs_id, + PVFS_handle handle, + int read_only_flag, + int schedule, void *in_user_ptr, req_sched_id * out_id); +enum PVFS_server_mode PINT_req_sched_get_mode(void); + +int PINT_req_sched_change_mode(enum PVFS_server_mode mode, + void *user_ptr, + req_sched_id *id); + int PINT_req_sched_unpost(req_sched_id in_id, void **returned_user_ptr); @@ -72,8 +75,6 @@ int PINT_req_sched_testworld(int *inout_ req_sched_id * out_id_array, void **returned_user_ptr_array, req_sched_error_code * out_status_array); - -enum PVFS_server_mode PINT_req_sched_get_mode(void); #endif /* __REQUEST_SCHEDULER_H */