Context Navigation

← Previous Changeset
Next Changeset →

Changeset 8462

Timestamp:

07/30/10 13:59:40 (3 years ago)

Author:

wligon

Message:

*** empty log message ***

Location:

branches/Orange-Migrate-Tools/src

Files:

: 1 added
: 12 modified

client/sysint/client-state-machine.h (modified) (1 diff)
client/sysint/mgmt-migrate.sm (modified) (12 diffs)
proto/PINT-le-bytefield.c (modified) (7 diffs)
proto/pvfs2-req-proto.h (modified) (6 diffs)
server/get-attr.sm (modified) (34 diffs)
server/list-attr.sm (modified) (3 diffs)
server/migrate-create.sm (added)
server/migrate.sm (modified) (4 diffs)
server/module.mk.in (modified) (1 diff)
server/prelude.sm (modified) (1 diff)
server/pvfs2-server-req.c (modified) (2 diffs)
server/pvfs2-server.h (modified) (4 diffs)
server/unstuff.sm (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

branches/Orange-Migrate-Tools/src/client/sysint/client-state-machine.h

r8372	r8462
148	148	struct PINT_client_migrate_sm
149	149	{
150		char *dist_server;
	150	char *dest_server;
151	151	};
152	152

branches/Orange-Migrate-Tools/src/client/sysint/mgmt-migrate.sm

r8388	r8462
18	18	#include "PINT-reqproto-encode.h"
19	19	#include "pvfs2-internal.h"
20
	20	#include "bmi.h"
21	21
22	22	extern job_context_id pint_client_sm_context;
…	…
27	27	%%
28	28
29		machine pvfs2_client_mgmt_migrate_sm{
30
31		state init{
	29	machine pvfs2_client_mgmt_migrate_sm
	30	{
	31
	32	state init
	33	{
32	34	run mgmt_migrate_init;
33	35	default => migrate_setup_msgpair;
34	36	}
35	37
36		state migrate_setup_msgpair{
	38	state migrate_setup_msgpair
	39	{
37	40	run mgmt_migrate_setup_msgpair;
38	41	success => migrate_xfer_msgpair;
…	…
40	43	}
41	44
42		state migrate_xfer_msgpair{
	45	state migrate_xfer_msgpair
	46	{
43	47	jump pvfs2_msgpairarray_sm;
44	48	default => cleanup;
45	49	}
46	50
47		state cleanup{
	51	state cleanup
	52	{
48	53	run mgmt_migrate_cleanup;
49	54	default => terminate;
…	…
59	64	const PVFS_credentials *credentials,
60	65	PVFS_sys_op_id *op_id,
61		char *dist_ser,
	66	char *dest_ser,
62	67	PVFS_hint hints,
63	68	void *user_ptr)
…	…
94	99
95	100	/* fill in stuff in the union */
96		sm_p->u.migrate.d~~ist_server = di~~st_ser;
	101	sm_p->u.migrate.dest_server = dest_ser;
97	102	sm_p->error_code = 0;
98	103	sm_p->object_ref = ref;
…	…
107	112	PVFS_object_ref ref,
108	113	const PVFS_credentials *credentials,
109		char *dist_server,
	114	char *dest_server,
110	115	PVFS_hint hints)
111	116	{
112		PVFS_error ret = -PVFS_EINVAL, error = 0;
	117	PVFS_error ret = -PVFS_EINVAL, error = 0;
113	118	PVFS_sys_op_id op_id;
114	119
115	120	gossip_debug(GOSSIP_CLIENT_DEBUG, "PVFS_mgmt_migrate entered\n");
116	121
117		ret = PVFS_imgmt_migrate(ref, credentials, &op_id, dist_server, hints, NULL);
	122	ret = PVFS_imgmt_migrate(ref, credentials, &op_id, dest_server, hints, NULL);
118	123	if(ret)
119	124	{
120	125	PVFS_perror_gossip("PVFS_imgmt_migrate call", ret);
121		error = ret;
	126	error = ret;
122	127	}
123	128	else
…	…
164	169	int ret = -PVFS_EINVAL;
165	170	PINT_sm_msgpair_state *msg_p = NULL;
	171
	172
166	173
167	174	js_p->error_code = 0;
…	…
169	176	PINT_msgpair_init(&sm_p->msgarray_op);
170	177	msg_p = &sm_p->msgarray_op.msgpair;
	178
	179
	180	fprintf(stderr,"I made it here\n");
	181
	182	fprintf(stderr,"%s\n", sm_p->u.migrate.dest_server);
	183
	184
171	185
172	186	PINT_SERVREQ_MGMT_MIGRATE_FILL(
…	…
175	189	sm_p->object_ref.fs_id,
176	190	sm_p->object_ref.handle,
177		~~sm_p->u.migrate.di~~st_server,
178		sm_p->hints);
	191	sm_p->u.migrate.dest_server,
	192	sm_p->hints);
179	193
180	194	/stuff here as well /
181		msg_p->fs_id = sm_p->object_ref.fs_id;
182		msg_p->handle = sm_p->object_ref.handle;
183		~~msg_p->retry_flag = PVFS_MSGPAIR_NO~~_RETRY;
	195	msg_p->fs_id = sm_p->object_ref.fs_id;
	196	msg_p->handle = sm_p->object_ref.handle;
	197	msg_p->retry_flag = PVFS_MSGPAIR_RETRY;
184	198	msg_p->comp_fn = mgmt_migrate_comp_fn;
185
	199	fprintf(stderr,"fs_id %d\n",msg_p->fs_id);
	200	fprintf(stderr,"handle %llu\n",llu(msg_p->handle));
	201
186	202	ret = PINT_cached_config_map_to_server(
187	203	&msg_p->svr_addr, msg_p->handle, msg_p->fs_id);
188
	204	fprintf(stderr,"server = %lld\n", lld(msg_p->svr_addr));
189	205	if(ret)
190	206	{
…	…
192	208	js_p->error_code = ret;
193	209	}
194
	210
	211
195	212	PINT_sm_push_frame(smcb, 0, &sm_p->msgarray_op);
196	213
…	…
208	225
209	226	sm_p->error_code = js_p->error_code;
210
	227
	228	fprintf(stderr,"I made it to client cleanup\n");
	229
211	230	/do something involving cache or free allocated stuff/
212	231
…	…
223	242	*
224	243	* vim: ft=c ts=8 sts=4 sw=4 expandtab
225		*/
	244	*/
	245

branches/Orange-Migrate-Tools/src/proto/PINT-le-bytefield.c

r8367	r8462
280	280	break;
281	281	case PVFS_SERV_MGMT_MIGRATE:
282		/nothing special /
	282	req.u.mgmt_migrate.dest_server = tmp_name;
	283	reqsize = extra_size_PVFS_servreq_migrate;
	284	break;
	285	case PVFS_SERV_MIGRATE_CREATE:
	286	/nothin special for now/
283	287	break;
284	288	case PVFS_SERV_NUM_OPS: /* sentinel, should not hit */
…	…
452	456	CASE(PVFS_SERV_LISTATTR, listattr);
453	457	CASE(PVFS_SERV_MGMT_MIGRATE, mgmt_migrate);
	458	CASE(PVFS_SERV_MIGRATE_CREATE, migrate_create);
454	459
455	460	case PVFS_SERV_GETCONFIG:
…	…
550	555	CASE(PVFS_SERV_LISTATTR, listattr);
551	556	CASE(PVFS_SERV_TREE_GET_FILE_SIZE, tree_get_file_size);
	557	CASE(PVFS_SERV_MIGRATE_CREATE, migrate_create);
552	558
553	559	case PVFS_SERV_REMOVE:
…	…
666	672	CASE(PVFS_SERV_LISTATTR, listattr);
667	673	CASE(PVFS_SERV_MGMT_MIGRATE, mgmt_migrate);
	674	CASE(PVFS_SERV_MIGRATE_CREATE, migrate_create);
668	675
669	676	case PVFS_SERV_GETCONFIG:
…	…
754	761	CASE(PVFS_SERV_LISTATTR, listattr);
755	762	CASE(PVFS_SERV_TREE_GET_FILE_SIZE, tree_get_file_size);
	763	CASE(PVFS_SERV_MIGRATE_CREATE, migrate_create);
756	764
757	765	case PVFS_SERV_REMOVE:
…	…
922	930	case PVFS_SERV_MGMT_EVENT_MON:
923	931	case PVFS_SERV_MGMT_MIGRATE: //migrate
	932	case PVFS_SERV_MIGRATE_CREATE:
924	933
925	934	case PVFS_SERV_DELEATTR:
…	…
1085	1094	case PVFS_SERV_TREE_REMOVE:
1086	1095	case PVFS_SERV_MGMT_MIGRATE:
	1096	case PVFS_SERV_MIGRATE_CREATE:
1087	1097	/nothing to free /
1088	1098	break;

branches/Orange-Migrate-Tools/src/proto/pvfs2-req-proto.h

r8372	r8462
85	85	PVFS_SERV_TREE_GET_FILE_SIZE = 42,
86	86	PVFS_SERV_MGMT_MIGRATE = 43,
	87	PVFS_SERV_MIGRATE_CREATE = 44,
87	88	/* leave this entry last */
88	89	PVFS_SERV_NUM_OPS
…	…
1908	1909
1909	1910	struct PVFS_servreq_mgmt_migrate{
	1911	char *dest_server;
1910	1912	PVFS_handle handle;
1911	1913	PVFS_fs_id fs_id;
1912		~~char *dist_server;~~
1913	1914	};
1914	1915
1915	1916	endecode_fields_3_struct(
1916	1917	PVFS_servreq_mgmt_migrate,
	1918	string, dest_server,
1917	1919	PVFS_handle, handle,
1918		PVFS_fs_id, fs_id,
1919		string , dist_server );
	1920	PVFS_fs_id, fs_id);
	1921
	1922	#define extra_size_PVFS_servreq_migrate \
	1923	roundup8(PVFS_REQ_LIMIT_SEGMENT_BYTES+1)
1920	1924
1921	1925	#define PINT_SERVREQ_MGMT_MIGRATE_FILL(__req, \
…	…
1923	1927	__fsid, \
1924	1928	__handle, \
1925		__d~~ist_ser,~~ \
	1929	__dest_server, \
1926	1930	__hints) \
1927	1931	do{ \
…	…
1932	1936	(__req).u.mgmt_migrate.handle = (__handle); \
1933	1937	(__req).u.mgmt_migrate.fs_id = (__fsid); \
1934		(__req).u.mgmt_migrate.dist_server = (__dist_ser); \
1935		} while(0);
1936
1937
1938
	1938	(__req).u.mgmt_migrate.dest_server = __dest_server; \
	1939	} while(0)
	1940
	1941	/**************************************************************************/
	1942	/migrate-create/
	1943
	1944	struct PVFS_servreq_migrate_create
	1945	{
	1946	int32_t mask;
	1947	PVFS_ds_keyval *val;
	1948	PVFS_ds_keyval *key;
	1949	int32_t nkey;
	1950	PVFS_fs_id fs_id;
	1951	PVFS_handle handle;
	1952	PVFS_object_attr attr;
	1953	};
	1954
	1955	endecode_fields_4aa_struct(
	1956	PVFS_servreq_migrate_create,
	1957	PVFS_handle, handle,
	1958	PVFS_fs_id, fs_id,
	1959	int32_t, mask,
	1960	PVFS_object_attr, attr,
	1961	int32_t, nkey,
	1962	PVFS_ds_keyval, key,
	1963	PVFS_ds_keyval, val);
	1964
	1965	#define extra_size_PVFS_servreq_migrate_create \
	1966	((PVFS_REQ_LIMIT_KEY_LEN + PVFS_REQ_LIMIT_VAL_LEN) \
	1967	* PVFS_REQ_LIMIT_KEYVAL_LIST)
	1968
	1969	#define PINT_SERVREQ_MIGRATE_CREATE_FILL(__req, \
	1970	__creds, \
	1971	__fs_id, \
	1972	__handle, \
	1973	__mask, \
	1974	__attr, \
	1975	__key, \
	1976	__val, \
	1977	__nkey, \
	1978	__hints) \
	1979	do{ \
	1980	memset(&(__req), 0, sizeof(__req)); \
	1981	(__req).op = PVFS_SERV_MIGRATE_CREATE; \
	1982	(__req).credentials = (__creds); \
	1983	(__req).hints = (__hints); \
	1984	(__req).u.migrate_create.fs_id = (__fs_id); \
	1985	(__req).u.migrate_create.handle = (__handle); \
	1986	(__req).u.migrate_create.attr = (__attr); \
	1987	(__req).u.migrate_create.nkey = (__nkey); \
	1988	(__req).u.migrate_create.mask = (__mask); \
	1989	(__req).u.migrate_create.key = (__key); \
	1990	(__req).u.migrate_create.val = (__val); \
	1991	}while(0)
	1992
	1993
	1994
	1995	/* Types for mask used for migrate_create.sm */
	1996	#define MIGRATE_CREATE (1 << 0)
	1997	#define MIGRATE_STORE (1 << 1)
	1998
	1999
	2000	struct PVFS_servresp_migrate_create
	2001	{
	2002	PVFS_handle new_handle;
	2003	};
	2004
	2005	endecode_fields_1_struct(
	2006	PVFS_servresp_migrate_create,
	2007	PVFS_handle, new_handle);
	2008
	2009
	2010	/****************************************************************/
1939	2011
1940	2012
…	…
1985	2057	struct PVFS_servreq_tree_get_file_size tree_get_file_size;
1986	2058	struct PVFS_servreq_mgmt_migrate mgmt_migrate;
	2059	struct PVFS_servreq_migrate_create migrate_create;
1987	2060	} u;
1988	2061	};
…	…
2040	2113	struct PVFS_servresp_listattr listattr;
2041	2114	struct PVFS_servresp_tree_get_file_size tree_get_file_size;
	2115	struct PVFS_servresp_migrate_create migrate_create;
2042	2116	} u;
2043	2117	};

branches/Orange-Migrate-Tools/src/server/get-attr.sm

r8251	r8462
331	331	gossip_debug(GOSSIP_GETATTR_DEBUG,
332	332	" Req handle %llu refers to a metafile\n",
333		llu(s_op->u.getattr.handle));
334
335		if (s_op->u.getattr.attrmask & PVFS_ATTR_META_DFILES)
	333	llu(s_op->req->u.getattr.handle));
	334
	335	if (s_op->req->u.getattr.attrmask & PVFS_ATTR_META_DFILES)
336	336	{
337	337	gossip_debug(GOSSIP_GETATTR_DEBUG,
…	…
347	347	}
348	348
349		if (s_op->u.getattr.attrmask & PVFS_ATTR_META_DIST)
	349	if (s_op->req->u.getattr.attrmask & PVFS_ATTR_META_DIST)
350	350	{
351	351	gossip_debug(GOSSIP_GETATTR_DEBUG,
…	…
363	363	}
364	364
365		if (s_op->u.getattr.attrmask & PVFS_ATTR_META_MIRROR_DFILES)
	365	if (s_op->req->u.getattr.attrmask & PVFS_ATTR_META_MIRROR_DFILES)
366	366	{
367	367	gossip_debug(GOSSIP_GETATTR_DEBUG,"client wants mirrored "
…	…
393	393	gossip_debug(GOSSIP_GETATTR_DEBUG, " handle %llu refers to "
394	394	"a datafile (size = %lld).\n",
395		llu(s_op->u.getattr.handle),
	395	llu(s_op->req->u.getattr.handle),
396	396	lld(resp_attr->u.data.size));
397	397	break;
398	398	case PVFS_TYPE_DIRECTORY:
399	399	PINT_ACCESS_DEBUG(s_op, GOSSIP_ACCESS_DEBUG, "type: directory\n");
400		if (s_op->u.getattr.attrmask & PVFS_ATTR_DIR_DIRENT_COUNT)
	400	if (s_op->req->u.getattr.attrmask & PVFS_ATTR_DIR_DIRENT_COUNT)
401	401	{
402	402	gossip_debug(GOSSIP_GETATTR_DEBUG,
…	…
413	413	assert(resp_attr->mask & PVFS_ATTR_COMMON_ALL);
414	414	}
415		if (s_op->u.getattr.attrmask & PVFS_ATTR_DIR_HINT)
	415	if (s_op->req->u.getattr.attrmask & PVFS_ATTR_DIR_HINT)
416	416	{
417	417	gossip_debug(GOSSIP_GETATTR_DEBUG,
…	…
433	433	GOSSIP_GETATTR_DEBUG, " handle %llu refers to "
434	434	"a dirdata object. doing nothing special\n",
435		llu(s_op->u.getattr.handle));
	435	llu(s_op->req->u.getattr.handle));
436	436	assert(resp_attr->mask & PVFS_ATTR_COMMON_ALL);
437	437	break;
…	…
440	440	gossip_debug(
441	441	GOSSIP_GETATTR_DEBUG, " handle %llu refers to a symlink.\n",
442		llu(s_op->u.getattr.handle));
	442	llu(s_op->req->u.getattr.handle));
443	443
444	444	/*
…	…
460	460	"Error: got unknown type when verifying attributes for "
461	461	"handle %llu.\n",
462		llu(s_op->u.getattr.handle));
	462	llu(s_op->req->u.getattr.handle));
463	463	js_p->error_code = -PVFS_ENXIO;
464	464	break;
…	…
476	476
477	477	/* if we don't need to fill in the symlink target, skip it */
478		if (!(s_op->u.getattr.attrmask & PVFS_ATTR_SYMLNK_TARGET))
	478	if (!(s_op->req->u.getattr.attrmask & PVFS_ATTR_SYMLNK_TARGET))
479	479	{
480	480	gossip_debug(GOSSIP_GETATTR_DEBUG, "skipping symlink target read\n");
…	…
511	511
512	512	ret = job_trove_keyval_read(
513		s_op->~~u.getattr.fs_id, s_op~~->u.getattr.handle,
	513	s_op->req->u.getattr.fs_id, s_op->req->u.getattr.handle,
514	514	&s_op->key, &s_op->val,
515	515	0,
…	…
599	599	" reading metafile hint (coll_id = %d, "
600	600	"handle = %llu, key = %s (%d), val_buf = %p (%d))\n",
601		s_op->u.getattr.fs_id,
602		llu(s_op->u.getattr.handle), (char *)s_op->key.buffer,
	601	s_op->req->u.getattr.fs_id,
	602	llu(s_op->req->u.getattr.handle), (char *)s_op->key.buffer,
603	603	s_op->key.buffer_sz, s_op->val.buffer,
604	604	s_op->val.buffer_sz);
605	605
606	606	ret = job_trove_keyval_read(
607		s_op->~~u.getattr.fs_id, s_op~~->u.getattr.handle,
	607	s_op->req->u.getattr.fs_id, s_op->req->u.getattr.handle,
608	608	&s_op->key, &s_op->val,
609	609	0,
…	…
627	627
628	628	/* if we don't need to fill in the dfiles, skip them */
629		if (!(s_op->u.getattr.attrmask & PVFS_ATTR_META_DFILES))
	629	if (!(s_op->req->u.getattr.attrmask & PVFS_ATTR_META_DFILES))
630	630	{
631	631	gossip_debug(GOSSIP_GETATTR_DEBUG, "skipping data handle read\n");
…	…
660	660
661	661	gossip_err("handle: %llu (%llx), fsid: %d.\n",
662		llu(s_op->~~u.getattr.handle), llu(s_op~~->u.getattr.handle),
663		(int)s_op->u.getattr.fs_id);
	662	llu(s_op->req->u.getattr.handle), llu(s_op->req->u.getattr.handle),
	663	(int)s_op->req->u.getattr.fs_id);
664	664
665	665	/If we hit an error the DIST & DFILES are no longer valid/
…	…
700	700	" reading %d datafile handles (coll_id = %d, "
701	701	"handle = %llu, key = %s (%d), val_buf = %p (%d))\n",
702		dfile_count, s_op->u.getattr.fs_id,
703		llu(s_op->u.getattr.handle), (char *)s_op->key.buffer,
	702	dfile_count, s_op->req->u.getattr.fs_id,
	703	llu(s_op->req->u.getattr.handle), (char *)s_op->key.buffer,
704	704	s_op->key.buffer_sz, s_op->val.buffer,
705	705	s_op->val.buffer_sz);
706	706
707	707	ret = job_trove_keyval_read(
708		s_op->u.getattr.fs_id
709		,s_op->u.getattr.handle
	708	s_op->req->u.getattr.fs_id
	709	,s_op->req->u.getattr.handle
710	710	,&s_op->key
711	711	,&s_op->val
…	…
739	739	gossip_debug(GOSSIP_MIRROR_DEBUG,"\tMirroring is NOT turned on "
740	740	"for this handle(%llu)..\n"
741		,llu(s_op->u.getattr.handle));
	741	,llu(s_op->req->u.getattr.handle));
742	742	js_p->error_code = SKIP_NEXT_STATE;
743	743
…	…
747	747	gossip_debug(GOSSIP_MIRROR_DEBUG,"\tMirroring IS turned on for this "
748	748	"handle(%llu)...\n"
749		,llu(s_op->u.getattr.handle));
	749	,llu(s_op->req->u.getattr.handle));
750	750
751	751	js_p->error_code = 0;
…	…
772	772	/* submit job to read the value */
773	773	ret = job_trove_keyval_read(
774		s_op->u.getattr.fs_id
775		,s_op->u.getattr.handle
	774	s_op->req->u.getattr.fs_id
	775	,s_op->req->u.getattr.handle
776	776	,&s_op->key
777	777	,&s_op->val
…	…
942	942	/* call job to retrieve the key/val pairs */
943	943	ret = job_trove_keyval_read_list(
944		s_op->u.getattr.fs_id
945		,s_op->u.getattr.handle
	944	s_op->req->u.getattr.fs_id
	945	,s_op->req->u.getattr.handle
946	946	,s_op->key_a
947	947	,s_op->val_a
…	…
1119	1119
1120	1120	/* if we don't need to fill in the distribution, skip it */
1121		if (!(s_op->u.getattr.attrmask & PVFS_ATTR_META_DIST))
	1121	if (!(s_op->req->u.getattr.attrmask & PVFS_ATTR_META_DIST))
1122	1122	{
1123	1123	gossip_debug(GOSSIP_GETATTR_DEBUG, "skipping data handle "
…	…
1137	1137	{
1138	1138	gossip_err("Cannot Read Dist! Got an invalid dist size for "
1139		"handle %llu,%d\n",llu(s_op->u.getattr.handle),
1140		s_op->u.getattr.fs_id);
	1139	"handle %llu,%d\n",llu(s_op->req->u.getattr.handle),
	1140	s_op->req->u.getattr.fs_id);
1141	1141	js_p->error_code = -PVFS_EINVAL;
1142	1142	return SM_ACTION_COMPLETE;
…	…
1163	1163
1164	1164	ret = job_trove_keyval_read(
1165		s_op->~~u.getattr.fs_id, s_op~~->u.getattr.handle,
	1165	s_op->req->u.getattr.fs_id, s_op->req->u.getattr.handle,
1166	1166	&(s_op->key), &(s_op->val),
1167	1167	0,
…	…
1205	1205
1206	1206	return(job_trove_dspace_getattr(
1207		s_op->u.getattr.fs_id,
	1207	s_op->req->u.getattr.fs_id,
1208	1208	s_op->resp.u.getattr.attr.u.meta.dfile_array[0],
1209	1209	smcb,
…	…
1249	1249	}
1250	1250
1251		if(s_op->u.getattr.attrmask & PVFS_ATTR_META_DIST)
	1251	if(s_op->req->u.getattr.attrmask & PVFS_ATTR_META_DIST)
1252	1252	{
1253	1253	/* successfully read dist key; make sure we got something valid */
…	…
1274	1274	if(resp_attr->u.meta.dist == 0) {
1275	1275	gossip_err("Found dist of 0 for handle %llu,%d\n",
1276		llu(s_op->~~u.getattr.handle), s_op~~->u.getattr.fs_id);
	1276	llu(s_op->req->u.getattr.handle), s_op->req->u.getattr.fs_id);
1277	1277	PVFS_perror("Metafile getattr_setup_resp",js_p->error_code);
1278	1278	js_p->error_code = -PVFS_EIO;
…	…
1372	1372	{
1373	1373	gossip_err("Failed to retrieve symlink target path for "
1374		"handle %llu,%d\n",llu(s_op->u.getattr.handle),
1375		s_op->u.getattr.fs_id);
	1374	"handle %llu,%d\n",llu(s_op->req->u.getattr.handle),
	1375	s_op->req->u.getattr.fs_id);
1376	1376	PVFS_perror("Symlink retrieval failure",js_p->error_code);
1377	1377
…	…
1475	1475	struct PINT_smcb smcb, job_status_s js_p)
1476	1476	{
1477		~~struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);~~
1478		~~s_op->u.getattr.handle = s_op->req->u.getattr.handle;~~
1479		~~s_op->u.getattr.fs_id = s_op->req->u.getattr.fs_id;~~
1480		~~s_op->u.getattr.attrmask = s_op->req->u.getattr.attrmask;~~
1481
1482	1477	js_p->error_code = 0;
1483	1478	return SM_ACTION_COMPLETE;
…	…
1490	1485
1491	1486	if((js_p->error_code == 0) &&
1492		(s_op->u.getattr.attrmask & PVFS_ATTR_META_DFILES))
	1487	(s_op->req->u.getattr.attrmask & PVFS_ATTR_META_DFILES))
1493	1488	{
1494	1489	/* successfully read datafile key; make sure we got something valid */
…	…
1535	1530
1536	1531	ret = job_trove_keyval_read(
1537		s_op->~~u.getattr.fs_id, s_op~~->u.getattr.handle,
	1532	s_op->req->u.getattr.fs_id, s_op->req->u.getattr.handle,
1538	1533	&s_op->key, &s_op->val,
1539	1534	0,
…	…
1555	1550	job_id_t tmp_id;
1556	1551
1557		if (!(s_op->u.getattr.attrmask & PVFS_ATTR_DIR_DIRENT_COUNT))
	1552	if (!(s_op->req->u.getattr.attrmask & PVFS_ATTR_DIR_DIRENT_COUNT))
1558	1553	{
1559	1554	/* the caller didn't really want the dirent count; skip to get
…	…
1564	1559	}
1565	1560	ret = job_trove_keyval_get_handle_info(
1566		s_op->u.getattr.fs_id,
	1561	s_op->req->u.getattr.fs_id,
1567	1562	s_op->u.getattr.dirent_handle,
1568	1563	TROVE_KEYVAL_HANDLE_COUNT \|
…	…
1613	1608	*/
1614	1609
1615		if (!(s_op->u.getattr.attrmask & PVFS_ATTR_DIR_HINT))
	1610	if (!(s_op->req->u.getattr.attrmask & PVFS_ATTR_DIR_HINT))
1616	1611	{
1617	1612	/* the caller didn't really want the dir hints; skip
…	…
1627	1622	Trove_Special_Keys[DIST_PARAMS_KEY].key,
1628	1623	Trove_Special_Keys[NUM_DFILES_KEY].key,
1629		s_op->~~u.getattr.fs_id, llu(s_op~~->u.getattr.handle));
	1624	s_op->req->u.getattr.fs_id, llu(s_op->req->u.getattr.handle));
1630	1625
1631	1626	s_op->resp.u.getattr.attr.u.dir.hint.dist_params =
…	…
1704	1699	js_p->error_code = 0;
1705	1700	ret = job_trove_keyval_read_list(
1706		s_op->u.getattr.fs_id,
1707		s_op->u.getattr.handle,
	1701	s_op->req->u.getattr.fs_id,
	1702	s_op->req->u.getattr.handle,
1708	1703	s_op->key_a, s_op->val_a, s_op->u.getattr.err_array, NUM_SPECIAL_KEYS,
1709	1704	0, NULL, smcb, 0, js_p, &tmp_id,
…	…
1826	1821
1827	1822	return(job_trove_keyval_read(
1828		s_op->u.getattr.fs_id,
1829		s_op->u.getattr.handle,
	1823	s_op->req->u.getattr.fs_id,
	1824	s_op->req->u.getattr.handle,
1830	1825	&(s_op->key),
1831	1826	&(s_op->val),

branches/Orange-Migrate-Tools/src/server/list-attr.sm

r7471	r8462
142	142	continue;
143	143	}
144
145		getattr_op = malloc(sizeof(*getattr_op));
146		if(!getattr_op)
147		{
148		s_op->u.listattr.errors[i] = -PVFS_ENOMEM;
149		gossip_debug(GOSSIP_SERVER_DEBUG,
150		"listattr: failed to setup nested sm for handle: %llu\n",
151		llu(s_op->req->u.listattr.handles[i]));
152		continue;
153		}
154		memset(getattr_op, 0, sizeof(*getattr_op));
155
	144
	145	PINT_SETUP_LOCAL_FRAME(getattr_op);
	146	PINT_SERVREQ_GETATTR_FILL(*getattr_op->req,
	147	s_op->req->credentials,
	148	s_op->req->u.listattr.fs_id,
	149	s_op->req->u.listattr.handles[i],
	150	s_op->req->u.listattr.attrmask,
	151	s_op->req->hints);
156	152	/* TODO: need a way to explicitly set the right inputs to the
157	153	* getattr nested sm. This code block is very fragile.
…	…
166	162	* logging
167	163	*/
168		~~getattr_op->req = s_op->req;~~
	164
169	165	/* need to fill in the input parameters to the getattr nested machine */
170		getattr_op->u.getattr.fs_id = s_op->req->u.listattr.fs_id;
171		getattr_op->u.getattr.handle = s_op->req->u.listattr.handles[i];
172		getattr_op->u.getattr.attrmask = s_op->req->u.listattr.attrmask;
	166
173	167
174	168	ret = PINT_sm_push_frame(smcb, 0, getattr_op);
…	…
233	227	for(j=0; j<s_op->req->u.listattr.nhandles; j++)
234	228	{
235		if(s_op->req->u.listattr.handles[j] == getattr_op->u.getattr.handle)
	229	if(s_op->req->u.listattr.handles[j] == getattr_op->req->u.getattr.handle)
236	230	{
237	231	s_op->u.listattr.attr_a[j] = getattr_op->resp.u.getattr.attr;

branches/Orange-Migrate-Tools/src/server/migrate.sm

r8388	r8462
10	10	#include "pvfs2-server.h"
11	11	#include "pvfs2-internal.h"
	12	#include "pvfs2-attr.h"
	13	#include "pvfs2-util.h"
	14	#include "pint-util.h"
	15	#include "pint-cached-config.h"
	16	#include "pvfs2-dist-basic.h"
	17
	18
	19	static int migrate_create_msg_comp_fn(
	20	void v_p, struct PVFS_server_resp resp, int i);
	21
12	22
13	23
…	…
19	29	{
20	30	jump pvfs2_prelude_sm;
21		success => test_stuff;
22		/success => get_new_handle;/
23		default => final_response;
24		}
25
26		state test_stuff
27		{
28		run test_stuff;
29		default => final_response;
30		}
31
32		state get_new_handle
33		{
34		run migrate_get_new_handle;
35		default => final_response;
36		}
37
	31	success => test_stuff;
	32	default => final_response;
	33
	34	}
	35
	36	state test_stuff
	37	{
	38	run test_stuff;
	39	success => get_dest_server;
	40	default => final_response;
	41	}
	42
	43	state get_dest_server
	44	{
	45	run migrate_get_dest_server;
	46	success => setup_get_attr;
	47	default => final_response;
	48	}
	49
	50	state setup_get_attr
	51	{
	52	run migrate_setup_get_attr;
	53	success => get_attr_work;
	54	default => final_response;
	55	}
	56	state get_attr_work
	57	{
	58	jump pvfs2_get_attr_work_sm;
	59	default => interpret_get_attr;
	60	}
	61
	62	state interpret_get_attr
	63	{
	64	run migrate_interpret_get_attr;
	65	success => setup_migrate_create_msgpair;
	66	default => final_response;
	67	}
	68
	69	state setup_migrate_create_msgpair
	70	{
	71	run migrate_setup_migrate_create_msgpair;
	72	success => xfer_msgpair;
	73	default => final_response;
	74	}
	75
	76	state xfer_msgpair
	77	{
	78	jump pvfs2_msgpairarray_sm;
	79	default => final_response;
	80	}
	81
	82
38	83	state final_response
39	84	{
…	…
44	89	state cleanup
45	90	{
46		run migrate_cleanup;
47		default => terminate;
	91	run migrate_cleanup;
	92	default => terminate;
48	93	}
49	94
…	…
55	100	struct PINT_smcb smcb, job_status_s js_p)
56	101	{
	102	gossip_debug(GOSSIP_SERVER_DEBUG,"test stuff in server migrate sm\n");
57	103	struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
58		PVFS_handle *handle = s_op->u.mgmt_migrate.metahandle;
59		PVFS_fs_id fs_id = s_op->u.mgmt_migrate.fs_id;
60		~~int64_t dist_server = s_op->u.mgmt_migrate.di~~st_server;
61
62		~~printf("dist server: %ll\n", di~~st_server);
63		~~printf(~~"data handle: %llu\n", llu(handle));
64		~~printf(~~"file system ID: %d\n", fs_id);
	104	PVFS_handle handle = s_op->req->u.mgmt_migrate.handle;
	105	PVFS_fs_id fs_id = s_op->req->u.mgmt_migrate.fs_id;
	106	char *dest_server = s_op->req->u.mgmt_migrate.dest_server;
	107	gossip_debug(GOSSIP_SERVER_DEBUG,"made it to teststuff\n");
	108	gossip_debug(GOSSIP_SERVER_DEBUG,"dest server: %s\n", dest_server);
	109	gossip_debug(GOSSIP_SERVER_DEBUG,"data handle: %llu\n", llu(handle));
	110	gossip_debug(GOSSIP_SERVER_DEBUG,"file system ID: %d\n", fs_id);
65	111
66	112	return SM_ACTION_COMPLETE;
67	113	}
68	114
69		static PINT_sm_action migrate_get_new_handle(
70		struct PINT_smcb smcb, job_status_s js_p)
71		{
72
73
74		return SM_ACTION_COMPLETE;
75		}
76
	115	static PINT_sm_action migrate_get_dest_server(
	116	struct PINT_smcb smcb, job_status_s js_p)
	117	{
	118	gossip_debug(GOSSIP_SERVER_DEBUG,"Entered migrate_get_dest_server\n");
	119	struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
	120	char *dest_server;
	121	struct server_configuration_s *config_s = get_server_config_struct();
	122
	123	dest_server = PINT_config_get_host_addr_ptr(
	124	config_s, s_op->req->u.mgmt_migrate.dest_server);
	125
	126	gossip_debug(GOSSIP_SERVER_DEBUG,"dest_server: %s\n", dest_server);
	127	s_op->u.mgmt_migrate.dest_server = dest_server;
	128	if(!dest_server)
	129	{
	130	gossip_debug(GOSSIP_SERVER_DEBUG,"Bad server alias\n");
	131	return SM_ACTION_COMPLETE;
	132	}
	133
	134	return SM_ACTION_COMPLETE;
	135	}
	136
	137
77	138
78	139	static PINT_sm_action migrate_cleanup(
79		struct PINT_smcb smcb, job_status_s jp_p)
80		{
81
82
83
	140	struct PINT_smcb smcb, job_status_s js_p)
	141	{
	142	//struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
	143	gossip_debug(GOSSIP_SERVER_DEBUG,"Entered migrate_cleanup\n");
84	144	return(server_state_machine_complete(smcb));
85	145	}
86	146
87	147
88		/* need to know what some of these things are/mean!!!!!!!! */
	148	/*****************************************************************************/
	149	/Get attr half of migratation/
	150
	151	static PINT_sm_action migrate_setup_get_attr(
	152	struct PINT_smcb smcb, job_status_s js_p)
	153	{
	154
	155	gossip_debug(GOSSIP_SERVER_DEBUG,"Entered migrate_setup_get_attr\n");
	156	struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
	157	struct PINT_server_op *getattr_op;
	158	int ret;
	159
	160	js_p->error_code = 0;
	161
	162	/setup op for local server call to getattr/
	163	PINT_SETUP_LOCAL_FRAME(getattr_op);
	164	PINT_SERVREQ_GETATTR_FILL( *getattr_op->req,
	165	s_op->req->credentials,
	166	s_op->req->u.mgmt_migrate.fs_id,
	167	s_op->req->u.mgmt_migrate.handle,
	168	PVFS_ATTR_COMMON_ALL,
	169	s_op->req->hints);
	170
	171
	172	getattr_op->attr = s_op->attr;
	173
	174	ret = PINT_sm_push_frame(smcb, 0, getattr_op);
	175	if(ret < 0)
	176	{
	177	js_p->error_code = ret;
	178	}
	179	return SM_ACTION_COMPLETE;
	180	}
	181
	182
	183
	184	static PINT_sm_action migrate_interpret_get_attr(
	185	struct PINT_smcb smcb, job_status_s js_p)
	186	{
	187	gossip_debug(GOSSIP_SERVER_DEBUG,"Entered migrate_interpret_get_attr \n");
	188	struct PINT_server_op *getattr_op;
	189	struct PINT_server_op *s_op;
	190	int task_id;
	191	int remaining;
	192
	193	getattr_op = PINT_sm_pop_frame( smcb, &task_id, &js_p->error_code,
	194	&remaining);
	195	s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
	196
	197	if(js_p->error_code)
	198	{
	199	gossip_debug(GOSSIP_SERVER_DEBUG,"Migrate failed to retrieve attrs\n");
	200	return(SM_ACTION_COMPLETE);
	201	}
	202
	203	s_op->u.mgmt_migrate.attr = getattr_op->resp.u.getattr.attr;
	204
	205	free(getattr_op);
	206
	207	gossip_debug(GOSSIP_SERVER_DEBUG,"Should have gotten migrated file attr\n");
	208
	209	return SM_ACTION_COMPLETE;
	210	}
	211
	212
	213
	214	static PINT_sm_action migrate_setup_migrate_create_msgpair(
	215	struct PINT_smcb smcb, job_status_s js_p)
	216	{
	217	struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
	218	int ret = -PVFS_EINVAL;
	219	PINT_sm_msgpair_state *msg_p = NULL;
	220
	221	js_p->error_code = 0;
	222
	223	PVFS_object_attr *a_p = NULL;
	224
	225	a_p = &s_op->u.mgmt_migrate.attr;
	226
	227	gossip_debug(GOSSIP_SERVER_DEBUG,"Entered migrate_setup_migrate_create_msgpair\n");
	228	PINT_msgpair_init(&s_op->msgarray_op);
	229	msg_p = &s_op->msgarray_op.msgpair;
	230
	231	PINT_SERVREQ_MIGRATE_CREATE_FILL(
	232	msg_p->req,
	233	s_op->req->credentials,
	234	s_op->req->u.mgmt_migrate.fs_id,
	235	PVFS_HANDLE_NULL,
	236	MIGRATE_CREATE,
	237	s_op->u.mgmt_migrate.attr,
	238	NULL,
	239	NULL,
	240	0,
	241	s_op->req->hints);
	242
	243
	244	gossip_debug(GOSSIP_SERVER_DEBUG, " attrs read from request:\n\t"
	245	"[owner = %d, group = %d, perms = %o, type = %d]\n",
	246	(a_p->mask & PVFS_ATTR_COMMON_UID) ? a_p->owner : -1,
	247	(a_p->mask & PVFS_ATTR_COMMON_GID) ? a_p->group : -1,
	248	(a_p->mask & PVFS_ATTR_COMMON_PERM) ? a_p->perms : -1,
	249	(a_p->mask & PVFS_ATTR_COMMON_TYPE) ? a_p->objtype : -1);
	250
	251
	252
	253	msg_p->fs_id = s_op->req->u.mgmt_migrate.fs_id;
	254	msg_p->retry_flag = PVFS_MSGPAIR_RETRY;
	255	msg_p->comp_fn = migrate_create_msg_comp_fn;
	256
	257	ret = BMI_addr_lookup(&msg_p->svr_addr, s_op->u.mgmt_migrate.dest_server);
	258
	259	if(ret)
	260	{
	261	gossip_err("Failed to loop up meta server address\n");
	262	js_p->error_code = ret;
	263	}
	264
	265
	266	PINT_sm_push_frame(smcb, 0 ,&s_op->msgarray_op);
	267	return SM_ACTION_COMPLETE;
	268	}
	269
	270
	271	/*******************************************************************/
	272
	273
	274	static int migrate_create_msg_comp_fn(
	275	void v_p, struct PVFS_server_resp resp_p, int i)
	276	{
	277	PINT_smcb *smcb = v_p;
	278	struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_MSGPAIR_PARENT_SM);
	279
	280	gossip_debug(GOSSIP_SERVER_DEBUG,"migrate_create_msg_comp_fn\n");
	281	gossip_debug( GOSSIP_SERVER_DEBUG, "Metafile handle created: %llu\n", llu(resp_p->u.migrate_create.new_handle));
	282	assert(resp_p->op == PVFS_SERV_MIGRATE_CREATE);
	283
	284	if(resp_p->status != 0)
	285	{
	286	return resp_p->status;
	287	}
	288
	289	resp_p->u.migrate_create.new_handle = s_op->u.mgmt_migrate.dest_handle;
	290
	291	return 0;
	292	}
	293
	294
	295	static inline int PINT_get_object_ref_migrate(struct PVFS_server_req *req,
	296	PVFS_fs_id *fs_id,
	297	PVFS_handle *handle)
	298	{
	299	*fs_id = req->u.mgmt_migrate.fs_id;
	300	*handle = req->u.mgmt_migrate.handle;
	301	return 0;
	302	}
	303
	304	/* need to know what some of these things are/mean*/
89	305	struct PINT_server_req_params pvfs2_mgmt_migrate_params =
90	306	{
91	307	.string_name = "migrate",
92	308	.perm = PINT_SERVER_CHECK_NONE,
	309	.access_type = PINT_server_req_modify,
	310	.sched_policy = PINT_SERVER_REQ_SCHEDULE,
	311	.get_object_ref = PINT_get_object_ref_migrate,
93	312	.state_machine = &pvfs2_mgmt_migrate_sm
94	313	};
95
96	314
97	315	/*

branches/Orange-Migrate-Tools/src/server/module.mk.in

r8317	r8462
47	47	$(DIR)/precreate-pool-refiller.c \
48	48	$(DIR)/unstuff.c \
49		$(DIR)/tree-communicate.c
	49	$(DIR)/tree-communicate.c \
	50	$(DIR)/migrate.c \
	51	$(DIR)/migrate-create.c
50	52
51	53	# c files that should be added to server library

branches/Orange-Migrate-Tools/src/server/prelude.sm

r8317	r8462
90	90	int ret;
91	91	struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
92
93	92	ret = PINT_server_req_get_object_ref(
94	93	s_op->req, &s_op->target_fs_id, &s_op->target_handle);

branches/Orange-Migrate-Tools/src/server/pvfs2-server-req.c

r8098	r8462
52	52	extern struct PINT_server_req_params pvfs2_tree_remove_params;
53	53	extern struct PINT_server_req_params pvfs2_tree_get_file_size_params;
	54	extern struct PINT_server_req_params pvfs2_mgmt_migrate_params;
	55	extern struct PINT_server_req_params pvfs2_migrate_create_params;
54	56
55	57	/* table of incoming request types and associated parameters */
…	…
99	101	/* 41 */ {PVFS_SERV_TREE_REMOVE, &pvfs2_tree_remove_params},
100	102	/* 42 */ {PVFS_SERV_TREE_GET_FILE_SIZE, &pvfs2_tree_get_file_size_params},
	103	/* 43 */ {PVFS_SERV_MGMT_MIGRATE, &pvfs2_mgmt_migrate_params},
	104	/* 44 */ {PVFS_SERV_MIGRATE_CREATE, &pvfs2_migrate_create_params},
101	105	};
102	106

branches/Orange-Migrate-Tools/src/server/pvfs2-server.h

r8388	r8462
530	530	};
531	531
	532
	533	/This macro is used for other server operations to make a local call to get-attr/
	534
	535	#define PINT_SETUP_LOCAL_FRAME(__s_op) \
	536	do{ \
	537	__s_op = malloc(sizeof(struct PINT_server_op)); \
	538	if(!__s_op){js_p->error_code = -PVFS_ENOMEM; return SM_ACTION_COMPLETE;} \
	539	memset(__s_op, 0, sizeof(struct PINT_server_op)); \
	540	__s_op->req = &__s_op->decoded.stub_dec.req; \
	541	}while(0)
	542
	543
	544
532	545	struct PINT_server_getattr_op
533	546	{
…	…
579	592	struct PINT_server_mgmt_migrate_op
580	593	{
581		PVFS_handle *metahandle;
582		PVFS_fs_id fs_id;
583		int64_t dist_server;
584		/need dest server address /
	594	char *dest_server;
	595	PVFS_object_attr attr;
	596	PVFS_handle dest_handle;
585	597	};
586	598
	599
	600	struct PINT_server_migrate_create_op
	601	{
	602	PVFS_handle new_handle;
	603	PVFS_ds_attributes *ds_attr;
	604	};
587	605
588	606
…	…
679	697	struct PINT_server_tree_communicate_op tree_communicate;
680	698	struct PINT_server_mgmt_migrate_op mgmt_migrate;
	699	struct PINT_server_migrate_create_op migrate_create;
681	700	} u;
682	701
…	…
745	764	extern struct PINT_state_machine_s pvfs2_tree_remove_work_sm;
746	765	extern struct PINT_state_machine_s pvfs2_tree_get_file_size_work_sm;
747		extern struct PINT_state_machine_s pvfs2_m~~gmt_migr~~ate_sm;
	766	extern struct PINT_state_machine_s pvfs2_migrate_create_create_sm;
748	767
749	768	/* Exported Prototypes */

branches/Orange-Migrate-Tools/src/server/unstuff.sm

r8317	r8462
403	403	js_p->error_code = 0;
404	404
405		~~getattr_op = malloc(sizeof(*getattr_op)~~);
406		~~if(!getattr_op)~~
407		{
408		~~js_p->error_code = -PVFS_ENOMEM;~~
409		~~return SM_ACTION_COMPLETE;~~
410		}
411		~~memset(getattr_op, 0, sizeof(*getattr_op)~~);
	405	PINT_SETUP_LOCAL_FRAME(getattr_op);
	406	PINT_SERVREQ_GETATTR_FILL(*getattr_op->req,
	407	s_op->req->credentials,
	408	s_op->req->u.unstuff.fs_id,
	409	s_op->req->u.unstuff.handle,
	410	s_op->req->u.unstuff.attrmask,
	411	s_op->req->hints);
412	412
413	413	/* TODO: can we come up with a way to clean up and nail down what has
…	…
417	417	/* need attrs that the prelude read already */
418	418	getattr_op->attr = s_op->attr;
419		/* need a valid request structure for some generic features like access
420		* logging
421		*/
422		getattr_op->req = s_op->req;
423		/* need to fill in the input parameters to the getattr nested machine */
424		getattr_op->u.getattr.fs_id = s_op->req->u.unstuff.fs_id;
425		getattr_op->u.getattr.handle = s_op->req->u.unstuff.handle;
426		getattr_op->u.getattr.attrmask = s_op->req->u.unstuff.attrmask;
	419
427	420
428	421	ret = PINT_sm_push_frame(smcb, 0, getattr_op);

Download in other formats: