Attachment #316 for ticket #345

View | Details | Raw Unified | Return to ticket 345
Collapse All | Expand All

Lines 3-8 documents those changes that are of interest to users and admins. Link Here

(-)a/NEWS (+1 lines)
3		3
4	* Changes in Slurm 13.12.0pre1	4	* Changes in Slurm 13.12.0pre1
5	==============================	5	==============================
		6	-- sview - improve scalability
6		7
7	* Changes in Slurm 2.6.0	8	* Changes in Slurm 2.6.0
8	========================	9	========================




	return NULL;
}

static void _block_info_free(sview_block_info_t *block_ptr)
{
	sview_block_info_t *block_ptr = (sview_block_info_t *)object;

	if (block_ptr) {
		xfree(block_ptr->bg_block_name);
		xfree(block_ptr->slurm_part_name);

		/* don't xfree(block_ptr->mp_inx);
		   it isn't copied like the chars and is freed in the api
		*/
	}
}

static void _block_list_del(void *object)
{
	sview_block_info_t *block_ptr = (sview_block_info_t *)object;

	if (block_ptr) {
		_block_info_free(block_ptr);
		xfree(block_ptr);
	}
}


			_update_block_record(block_ptr,
					     GTK_TREE_STORE(model));
		else {
			_append_block_record(block_ptr,
					     GTK_TREE_STORE(model));
			block_ptr->iter_set = true;
			 * goto add */
			if (gtk_tree_model_get_iter(
				    model, &block_ptr->iter_ptr, path)) {
				do {
					/* search for the jobid and
					   check to see if it is in
					   the list */
					gtk_tree_model_get(
						model,
						&block_ptr->iter_ptr,
						SORTID_BLOCK,
						&name, -1);
					if (!strcmp(name,
						    block_ptr->bg_block_name)) {
						/* update with new info */
						g_free(name);
						_update_block_record(
							block_ptr,
							GTK_TREE_STORE(model));
						block_ptr->iter_set = 1;
						break;
					}
					g_free(name);
				} while (gtk_tree_model_iter_next(
						 model,
						 &block_ptr->iter_ptr));
			}

			if (!block_ptr->iter_set) {
				_append_block_record(block_ptr,
						    GTK_TREE_STORE(model));
				block_ptr->iter_set = true;
			}
			gtk_tree_path_free(path);
		}
	}


	static List block_list = NULL;
	static partition_info_msg_t *last_part_info_ptr = NULL;
	static block_info_msg_t *last_block_info_ptr = NULL;
	List last_list = NULL;
	ListIterator last_list_itr = NULL;
	sview_block_info_t *block_ptr = NULL;
	char tmp_mp_str[50];



			return block_list;
		}
		last_list = block_list;
	}

	block_list = list_create(_block_list_del);
	if (!block_list) {
		g_print("malloc error\n");
		return NULL;


	last_block_info_ptr = block_info_ptr;

	if (last_list)
		last_list_itr = list_iterator_create(last_list);
	for (i=0; i<block_info_ptr->record_count; i++) {
		/* If we don't have a block name just continue since
		   ths block hasn't been made in the system yet. */
		if (!block_info_ptr->block_array[i].bg_block_id)
			continue;

		block_ptr = NULL;

		if (last_list_itr) {
			while ((block_ptr = list_next(last_list_itr))) {
				if (!strcmp(block_ptr->bg_block_name,
					    block_info_ptr->
					    block_array[i].bg_block_id)) {
					list_remove(last_list_itr);
					_block_info_free(block_ptr);
					break;
				}
			}
			list_iterator_reset(last_list_itr);
		}

		if (!block_ptr)
			block_ptr = xmalloc(sizeof(sview_block_info_t));
		block_ptr->pos = i;
		block_ptr->bg_block_name
			= xstrdup(block_info_ptr->

	list_sort(block_list,
		  (ListCmpF)_sview_block_sort_aval_dec);

	if (last_list) {
		list_iterator_destroy(last_list_itr);
		list_destroy(last_list);
	}

	return block_list;
}

Lines 36-44 Link Here

(-)a/src/sview/front_end_info.c (-66 / +89 lines)
36	/* Collection of data for printing reports. Like data is combined here */	36	/* Collection of data for printing reports. Like data is combined here */
37	typedef struct {	37	typedef struct {
38	int color_inx;	38	int color_inx;
		39	char *front_end_name;
39	front_end_info_t *front_end_ptr;	40	front_end_info_t *front_end_ptr;
		41	GtkTreeIter iter_ptr;
		42	bool iter_set;
40	char *boot_time;	43	char *boot_time;
41	int node_inx[3];	44	int node_inx[3];
		45	int pos;
42	char *reason;	46	char *reason;
43	char *slurmd_start_time;	47	char *slurmd_start_time;
44	char *state;	48	char *state;
Lines 68-73 enum { Link Here
68	SORTID_REASON,	72	SORTID_REASON,
69	SORTID_SLURMD_START_TIME,	73	SORTID_SLURMD_START_TIME,
70	SORTID_STATE,	74	SORTID_STATE,
		75	SORTID_UPDATED,
71	SORTID_CNT	76	SORTID_CNT
72	};	77	};
73		78
Lines 109-114 static display_data_t display_data_front_end[] = { Link Here
109	refresh_front_end, create_model_front_end, admin_edit_front_end},	114	refresh_front_end, create_model_front_end, admin_edit_front_end},
110	{G_TYPE_POINTER, SORTID_NODE_INX, NULL, FALSE, EDIT_NONE,	115	{G_TYPE_POINTER, SORTID_NODE_INX, NULL, FALSE, EDIT_NONE,
111	refresh_front_end, create_model_front_end, admin_edit_front_end},	116	refresh_front_end, create_model_front_end, admin_edit_front_end},
		117	{G_TYPE_INT, SORTID_UPDATED, NULL, FALSE, EDIT_NONE,
		118	refresh_resv, create_model_resv, admin_edit_resv},
112	{G_TYPE_NONE, -1, NULL, FALSE, EDIT_NONE}	119	{G_TYPE_NONE, -1, NULL, FALSE, EDIT_NONE}
113	};	120	};
114		121
Lines 132-147 static void _admin_front_end(GtkTreeModel model, GtkTreeIter iter, char *type, Link Here
132	static void _process_each_front_end(GtkTreeModel model, GtkTreePath path,	139	static void _process_each_front_end(GtkTreeModel model, GtkTreePath path,
133	GtkTreeIter*iter, gpointer userdata);	140	GtkTreeIter*iter, gpointer userdata);
134		141
135	static void _front_end_info_list_del(void *object)	142	static void _front_end_info_free(sview_front_end_info_t *sview_front_end_info)
136	{	143	{
137	sview_front_end_info_t *sview_front_end_info;
138
139	sview_front_end_info = (sview_front_end_info_t *)object;
140	if (sview_front_end_info) {	144	if (sview_front_end_info) {
141	xfree(sview_front_end_info->boot_time);	145	xfree(sview_front_end_info->boot_time);
142	xfree(sview_front_end_info->reason);	146	xfree(sview_front_end_info->reason);
143	xfree(sview_front_end_info->slurmd_start_time);	147	xfree(sview_front_end_info->slurmd_start_time);
144	xfree(sview_front_end_info->state);	148	xfree(sview_front_end_info->state);
		149	}
		150	}
		151
		152	static void _front_end_info_list_del(void *object)
		153	{
		154	sview_front_end_info_t *sview_front_end_info;
		155
		156	sview_front_end_info = (sview_front_end_info_t *)object;
		157	if (sview_front_end_info) {
		158	_front_end_info_free(sview_front_end_info);
145	xfree(sview_front_end_info);	159	xfree(sview_front_end_info);
146	}	160	}
147	}	161	}
Lines 210-224 static void _layout_front_end_record(GtkTreeView *treeview, Link Here
210		224
211	static void _update_front_end_record(	225	static void _update_front_end_record(
212	sview_front_end_info_t *sview_front_end_info_ptr,	226	sview_front_end_info_t *sview_front_end_info_ptr,
213	GtkTreeStore *treestore,	227	GtkTreeStore *treestore)
214	GtkTreeIter *iter)
215	{	228	{
216	front_end_info_t *front_end_ptr;	229	front_end_info_t *front_end_ptr;
217		230
218	front_end_ptr = sview_front_end_info_ptr->front_end_ptr;	231	front_end_ptr = sview_front_end_info_ptr->front_end_ptr;
219		232
220	/* Combining these records provides a slight performance improvement */	233	/* Combining these records provides a slight performance improvement */
221	gtk_tree_store_set(treestore, iter,	234	gtk_tree_store_set(treestore, &sview_front_end_info_ptr->iter_ptr,
222	SORTID_ALLOW_GROUPS, front_end_ptr->allow_groups,	235	SORTID_ALLOW_GROUPS, front_end_ptr->allow_groups,
223	SORTID_ALLOW_USERS, front_end_ptr->allow_users,	236	SORTID_ALLOW_USERS, front_end_ptr->allow_users,
224	SORTID_BOOT_TIME,	237	SORTID_BOOT_TIME,
Lines 236-241 static void _update_front_end_record( Link Here
236	SORTID_SLURMD_START_TIME,	249	SORTID_SLURMD_START_TIME,
237	sview_front_end_info_ptr->slurmd_start_time,	250	sview_front_end_info_ptr->slurmd_start_time,
238	SORTID_STATE, sview_front_end_info_ptr->state,	251	SORTID_STATE, sview_front_end_info_ptr->state,
		252	SORTID_UPDATED, 1,
239	-1);	253	-1);
240		254
241	return;	255	return;
Lines 243-319 static void _update_front_end_record( Link Here
243		257
244	static void _append_front_end_record(	258	static void _append_front_end_record(
245	sview_front_end_info_t *sview_front_end_info_ptr,	259	sview_front_end_info_t *sview_front_end_info_ptr,
246	GtkTreeStore treestore, GtkTreeIter iter,	260	GtkTreeStore *treestore)
247	int line)
248	{	261	{
249	gtk_tree_store_append(treestore, iter, NULL);	262	gtk_tree_store_append(treestore, &sview_front_end_info_ptr->iter_ptr,
250	gtk_tree_store_set(treestore, iter, SORTID_POS, line, -1);	263	NULL);
251	_update_front_end_record(sview_front_end_info_ptr, treestore, iter);	264	gtk_tree_store_set(treestore, &sview_front_end_info_ptr->iter_ptr,
		265	SORTID_POS, sview_front_end_info_ptr->pos, -1);
		266	_update_front_end_record(sview_front_end_info_ptr, treestore);
252	}	267	}
253		268
254	static void _update_info_front_end(List info_list, GtkTreeView *tree_view)	269	static void _update_info_front_end(List info_list, GtkTreeView *tree_view)
255	{	270	{
256	GtkTreePath *path = gtk_tree_path_new_first();
257	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);	271	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
258	GtkTreeIter iter;	272	static GtkTreeModel *last_model = NULL;
259	front_end_info_t *front_end_ptr = NULL;	273	char *name;
260	int line = 0;
261	char host = NULL, front_end_name = NULL;
262	ListIterator itr = NULL;	274	ListIterator itr = NULL;
263	sview_front_end_info_t *sview_front_end_info = NULL;	275	sview_front_end_info_t *sview_front_end_info = NULL;
264		276
265	/* get the iter, or find out the list is empty goto add */	277	set_for_update(model, SORTID_UPDATED);
266	if (gtk_tree_model_get_iter(model, &iter, path)) {
267	/* make sure all the reserves are still here */
268	while (1) {
269	if (!gtk_tree_model_iter_next(model, &iter)) {
270	break;
271	}
272	}
273	}
274		278
275	itr = list_iterator_create(info_list);	279	itr = list_iterator_create(info_list);
276	while ((sview_front_end_info = list_next(itr))) {	280	while ((sview_front_end_info = list_next(itr))) {
277	front_end_ptr = sview_front_end_info->front_end_ptr;	281	/* This means the tree_store changed (added new column
278	/* get the iter, or find out the list is empty goto add */	282	or something). */
279	if (!gtk_tree_model_get_iter(model, &iter, path)) {	283	if (last_model != model)
280	goto adding;	284	sview_front_end_info->iter_set = false;
281	}	285
282	line = 0;	286	if (sview_front_end_info->iter_set) {
283	while (1) {	287	gtk_tree_model_get(model,
284	/* search for the jobid and check to see if	288	&sview_front_end_info->iter_ptr,
285	it is in the list */	289	SORTID_NAME, &name, -1);
286	gtk_tree_model_get(model, &iter, SORTID_NAME,	290	if (strcmp(name,
287	&front_end_name, -1);	291	sview_front_end_info->front_end_name)) {
288	if (!strcmp(front_end_name, front_end_ptr->name)) {	292	/* Bad pointer */
289	/* update with new info */	293	sview_front_end_info->iter_set = false;
290	g_free(front_end_name);	294	//g_print("bad front_end iter pointer\n");
291	_update_front_end_record(sview_front_end_info,
292	GTK_TREE_STORE(model),
293	&iter);
294	goto found;
295	}
296	g_free(front_end_name);
297
298	line++;
299	if (!gtk_tree_model_iter_next(model, &iter)) {
300	break;
301	}	295	}
		296	g_free(name);
		297	}
		298	if (sview_front_end_info->iter_set)
		299	_update_front_end_record(sview_front_end_info,
		300	GTK_TREE_STORE(model));
		301	else {
		302	_append_front_end_record(sview_front_end_info,
		303	GTK_TREE_STORE(model));
		304	sview_front_end_info->iter_set = true;
302	}	305	}
303	adding:
304	_append_front_end_record(sview_front_end_info,
305	GTK_TREE_STORE(model),
306	&iter, line);
307	found:
308	;
309	}	306	}
310	list_iterator_destroy(itr);	307	list_iterator_destroy(itr);
311	if (host)
312	free(host);
313		308
314	gtk_tree_path_free(path);	309	/* remove all old front_ends */
315		310	remove_old(model, SORTID_UPDATED);
316	return;	311	last_model = model;
317	}	312	}
318		313
319	static List _create_front_end_info_list(	314	static List _create_front_end_info_list(
Lines 322-327 static List _create_front_end_info_list( Link Here
322	char *upper = NULL;	317	char *upper = NULL;
323	char user[32], time_str[32];	318	char user[32], time_str[32];
324	static List info_list = NULL;	319	static List info_list = NULL;
		320	List last_list = NULL;
		321	ListIterator last_list_itr = NULL;
325	int i = 0;	322	int i = 0;
326	sview_front_end_info_t *sview_front_end_info_ptr = NULL;	323	sview_front_end_info_t *sview_front_end_info_ptr = NULL;
327	front_end_info_t *front_end_ptr = NULL;	324	front_end_info_t *front_end_ptr = NULL;
Lines 330-348 static List _create_front_end_info_list( Link Here
330	goto update_color;	327	goto update_color;
331		328
332	if (info_list)	329	if (info_list)
333	list_flush(info_list);	330	last_list = info_list;
334	else
335	info_list = list_create(_front_end_info_list_del);
336		331
		332	info_list = list_create(_front_end_info_list_del);
337	if (!info_list) {	333	if (!info_list) {
338	g_print("malloc error\n");	334	g_print("malloc error\n");
339	return NULL;	335	return NULL;
340	}	336	}
341		337
		338	if (last_list)
		339	last_list_itr = list_iterator_create(last_list);
342	for (i = 0; i < front_end_info_ptr->record_count; i++) {	340	for (i = 0; i < front_end_info_ptr->record_count; i++) {
343	front_end_ptr = &(front_end_info_ptr->front_end_array[i]);	341	front_end_ptr = &(front_end_info_ptr->front_end_array[i]);
344	sview_front_end_info_ptr =	342
345	xmalloc(sizeof(sview_front_end_info_t));	343	sview_front_end_info_ptr = NULL;
		344
		345	if (last_list_itr) {
		346	while ((sview_front_end_info_ptr =
		347	list_next(last_list_itr))) {
		348	if (!strcmp(sview_front_end_info_ptr->
		349	front_end_name,
		350	front_end_ptr->name)) {
		351	list_remove(last_list_itr);
		352	_front_end_info_free(
		353	sview_front_end_info_ptr);
		354	break;
		355	}
		356	}
		357	list_iterator_reset(last_list_itr);
		358	}
		359	if (!sview_front_end_info_ptr)
		360	sview_front_end_info_ptr =
		361	xmalloc(sizeof(sview_front_end_info_t));
		362	sview_front_end_info_ptr->pos = i;
		363	sview_front_end_info_ptr->front_end_name = front_end_ptr->name;
346	sview_front_end_info_ptr->front_end_ptr = front_end_ptr;	364	sview_front_end_info_ptr->front_end_ptr = front_end_ptr;
347	sview_front_end_info_ptr->color_inx = i % sview_colors_cnt;	365	sview_front_end_info_ptr->color_inx = i % sview_colors_cnt;
348	if (g_node_info_ptr) {	366	if (g_node_info_ptr) {
Lines 390-395 static List _create_front_end_info_list( Link Here
390	list_append(info_list, sview_front_end_info_ptr);	408	list_append(info_list, sview_front_end_info_ptr);
391	}	409	}
392		410
		411	if (last_list) {
		412	list_iterator_destroy(last_list_itr);
		413	list_destroy(last_list);
		414	}
		415
393	update_color:	416	update_color:
394	return info_list;	417	return info_list;
395	}	418	}




	int color_inx;
	GtkTreeIter iter_ptr;
	bool iter_set;
	uint32_t job_id;
	job_info_t *job_ptr;
	int node_cnt;
	char *nodes;

	return buf;
}

static void _job_info_free(sview_job_info_t *sview_job_info)
{
	if (sview_job_info) {
		xfree(sview_job_info->nodes);
		if (sview_job_info->step_list) {
			list_destroy(sview_job_info->step_list);
			sview_job_info->step_list = NULL;
		}
	}
}

static void _job_info_list_del(void *object)
{
	sview_job_info_t *sview_job_info = (sview_job_info_t *)object;

	if (sview_job_info) {
		_job_info_free(sview_job_info);
		if (sview_job_info->step_list)
			list_destroy(sview_job_info->step_list);
		xfree(sview_job_info);
	}
}

			_update_job_record(sview_job_info,
					   GTK_TREE_STORE(model));
		else {
			_append_job_record(sview_job_info,
					   GTK_TREE_STORE(model));
			sview_job_info->iter_set = true;
			 * goto add */
			if (gtk_tree_model_get_iter(
				    model, &sview_job_info->iter_ptr, path)) {
				do {
					/* search for the jobid and
					   check to see if it is in
					   the list */
					gtk_tree_model_get(
						model,
						&sview_job_info->iter_ptr,
						SORTID_JOBID,
						&jobid, -1);
					if (jobid == job_ptr->job_id) {
						/* update with new info */
						_update_job_record(
							sview_job_info,
							GTK_TREE_STORE(model));
						sview_job_info->iter_set = 1;
						break;
					}
				} while (gtk_tree_model_iter_next(
						 model,
						 &sview_job_info->iter_ptr));
			}

			if (!sview_job_info->iter_set) {
				_append_job_record(sview_job_info,
						   GTK_TREE_STORE(model));
				sview_job_info->iter_set = true;
			}

			gtk_tree_path_free(path);
		}
	}
	list_iterator_destroy(itr);

{
	static List info_list = NULL;
	static List odd_info_list = NULL;
	List last_list = NULL;
	ListIterator last_list_itr = NULL;
	static job_info_msg_t *last_job_info_ptr = NULL;
	static job_step_info_response_msg_t *last_step_info_ptr = NULL;
	int i = 0, j = 0;


	if (info_list) {
		list_flush(info_list);
		last_list = odd_info_list;
		odd_info_list = list_create(_job_info_list_del);
	} else {
		info_list = list_create(NULL);
		odd_info_list = list_create(_job_info_list_del);

		g_print("malloc error\n");
		return NULL;
	}
	if (last_list)
		last_list_itr = list_iterator_create(last_list);
	for (i=0; i<job_info_ptr->record_count; i++) {
		job_ptr = &(job_info_ptr->job_array[i]);

		sview_job_info_ptr = NULL;

		if (last_list_itr) {
			while ((sview_job_info_ptr =
				list_next(last_list_itr))) {
				if (sview_job_info_ptr->job_id ==
				    job_ptr->job_id) {
					list_remove(last_list_itr);
					_job_info_free(sview_job_info_ptr);
					break;
				}
			}
			list_iterator_reset(last_list_itr);
		}

		if (!sview_job_info_ptr)
			sview_job_info_ptr = xmalloc(sizeof(sview_job_info_t));
		sview_job_info_ptr->job_ptr = job_ptr;
		sview_job_info_ptr->job_id = job_ptr->job_id;
		sview_job_info_ptr->step_list = list_create(NULL);
		sview_job_info_ptr->pos = i;
		sview_job_info_ptr->node_cnt = 0;


	list_sort(odd_info_list, (ListCmpF)_sview_job_sort_aval_dec);

	if (last_list) {
		list_iterator_destroy(last_list_itr);
		list_destroy(last_list);
	}

update_color:

	if (want_odd_states)




{
	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
	static GtkTreeModel *last_model = NULL;
	node_info_t *node_ptr = NULL;
	char *name;
	ListIterator itr = NULL;
	sview_node_info_t *sview_node_info = NULL;


	itr = list_iterator_create(info_list);
	while ((sview_node_info = (sview_node_info_t*) list_next(itr))) {
		node_ptr = sview_node_info->node_ptr;

		/* This means the tree_store changed (added new column
		   or something). */

		if (sview_node_info->iter_set) {
			gtk_tree_model_get(model, &sview_node_info->iter_ptr,
					   SORTID_NAME, &name, -1);
			if (strcmp(name, sview_node_info->node_name)) {
				/* Bad pointer */
				sview_node_info->iter_set = false;
				//g_print("bad node iter pointer\n");
			}
			g_free(name);
		}
		if (sview_node_info->iter_set)
			_update_node_record(sview_node_info,
					    GTK_TREE_STORE(model));
		else {
			_append_node_record(sview_node_info,
					    GTK_TREE_STORE(model));
			sview_node_info->iter_set = true;
			 * goto add */
			if (gtk_tree_model_get_iter(
				    model, &sview_node_info->iter_ptr, path)) {
				do {
					/* search for the node name and check
					 * to see if it is in the list */
					gtk_tree_model_get(
						model,
						&sview_node_info->iter_ptr,
						SORTID_NAME,
						&name, -1);
					if (name && node_ptr->name &&
					    !strcmp(name, node_ptr->name)) {
						/* update with new info */
						g_free(name);
						_update_node_record(
							sview_node_info,
							GTK_TREE_STORE(model));
						sview_node_info->iter_set = 1;
						break;
					}
					g_free(name);
				} while (gtk_tree_model_iter_next(
						 model,
						 &sview_node_info->iter_ptr));
			}

			if (!sview_node_info->iter_set) {
				_append_node_record(sview_node_info,
						    GTK_TREE_STORE(model));
				sview_node_info->iter_set = true;
			}
			gtk_tree_path_free(path);
		}
	}
	list_iterator_destroy(itr);

	last_model = model;
}

static void _node_info_free(sview_node_info_t *sview_node_info)
{
	sview_node_info_t *sview_node_info = (sview_node_info_t *)object;

	if (sview_node_info) {
		xfree(sview_node_info->slurmd_start_time);
		xfree(sview_node_info->boot_time);
		xfree(sview_node_info->node_name);
		xfree(sview_node_info->rack_mp);
		xfree(sview_node_info->reason);
	}
}

static void _node_info_list_del(void *object)
{
	sview_node_info_t *sview_node_info = (sview_node_info_t *)object;

	if (sview_node_info) {
		_node_info_free(sview_node_info);
		xfree(sview_node_info);
	}
}

{
	static List info_list = NULL;
	static node_info_msg_t *last_node_info_ptr = NULL;
	List last_list = NULL;
	ListIterator last_list_itr = NULL;
	int i = 0;
	sview_node_info_t *sview_node_info_ptr = NULL;
	node_info_t *node_ptr = NULL;

	last_node_info_ptr = node_info_ptr;

	if (info_list)
		last_list = info_list;

	info_list = list_create(_node_info_list_del);
	if (!info_list) {
		g_print("malloc error\n");
		return NULL;
	}

	if (last_list)
		last_list_itr = list_iterator_create(last_list);
	for (i=0; i<node_info_ptr->record_count; i++) {
		char *select_reason_str = NULL;
		node_ptr = &(node_info_ptr->node_array[i]);

		if (!node_ptr->name || (node_ptr->name[0] == '\0'))
			continue;

		sview_node_info_ptr = NULL;

		if (last_list_itr) {
			while ((sview_node_info_ptr =
				list_next(last_list_itr))) {
				if (!strcmp(sview_node_info_ptr->node_name,
					    node_ptr->name)) {
					list_remove(last_list_itr);
					_node_info_free(sview_node_info_ptr);
					break;
				}
			}
			list_iterator_reset(last_list_itr);
		}

		/* constrain list to included partitions' nodes */
		/* and there are excluded values to process */
		/* and user has not requested to show hidden */

		/*     && !check_part_includes_node(i)) */
		/* 	continue; */

		if (!sview_node_info_ptr)
			sview_node_info_ptr =
				xmalloc(sizeof(sview_node_info_t));
		list_append(info_list, sview_node_info_ptr);
		sview_node_info_ptr->node_name = xstrdup(node_ptr->name);
		sview_node_info_ptr->node_ptr = node_ptr;
		sview_node_info_ptr->pos = i;


				xstrdup(time_str);
		}
	}

	if (last_list) {
		list_iterator_destroy(last_list_itr);
		list_destroy(last_list);
	}

update_color:

	return info_list;




	int color_inx;
	GtkTreeIter iter_ptr;
	bool iter_set;
	char *part_name;
	/* part_info contains partition, avail, max_time, job_size,
	 * root, share, groups */
	partition_info_t* part_ptr;

{
	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
	static GtkTreeModel *last_model = NULL;
	partition_info_t *part_ptr = NULL;
	char *name = NULL;
	ListIterator itr = NULL;
	sview_part_info_t *sview_part_info = NULL;


	itr = list_iterator_create(info_list);
	while ((sview_part_info = (sview_part_info_t*) list_next(itr))) {
		part_ptr = sview_part_info->part_ptr;
		/* This means the tree_store changed (added new column
		   or something). */
		if (last_model != model)

		if (sview_part_info->iter_set) {
			gtk_tree_model_get(model, &sview_part_info->iter_ptr,
					   SORTID_NAME, &name, -1);
			if (strcmp(name, sview_part_info->part_name))
				/* Bad pointer */
				sview_part_info->iter_set = false;
			g_free(name);
		}

			_update_part_record(sview_part_info,
					    GTK_TREE_STORE(model));
		else {
			_append_part_record(sview_part_info,
					    GTK_TREE_STORE(model));
			sview_part_info->iter_set = true;
			 * goto add */
			if (gtk_tree_model_get_iter(
				    model, &sview_part_info->iter_ptr, path)) {
				do {
					/* search for the jobid and
					   check to see if it is in
					   the list */
					gtk_tree_model_get(
						model,
						&sview_part_info->iter_ptr,
						SORTID_NAME,
						&name, -1);
					if (!strcmp(name, part_ptr->name)) {
						/* update with new info */
						g_free(name);
						_update_part_record(
							sview_part_info,
							GTK_TREE_STORE(model));
						sview_part_info->iter_set = 1;
						break;
					}
					g_free(name);
				} while (gtk_tree_model_iter_next(
						 model,
						 &sview_part_info->iter_ptr));
			}

			if (!sview_part_info->iter_set) {
				_append_part_record(sview_part_info,
						    GTK_TREE_STORE(model));
				sview_part_info->iter_set = true;
			}
			gtk_tree_path_free(path);
		}
	}
	list_iterator_destroy(itr);

	return;
}

static void _part_info_free(sview_part_info_t *sview_part_info)
{
	if (sview_part_info) {
		xfree(sview_part_info->part_name);
		if (sview_part_info->sub_list)
			list_destroy(sview_part_info->sub_list);
	}
}

static void _part_info_list_del(void *object)
{
	sview_part_info_t *sview_part_info = (sview_part_info_t *)object;

	if (sview_part_info) {
		_part_info_free(sview_part_info);
			list_destroy(sview_part_info->sub_list);
		xfree(sview_part_info);
	}
}

	return SLURM_SUCCESS;
}

/*
 * _create_sview_part_info - create an sview_part_info record for
 *                           the given partition
 * part_ptr IN             - pointer to partition record to add
 * sview_part_info OUT     - ptr to an inited sview_part_info_t
 */
static sview_part_info_t *_create_sview_part_info(partition_info_t* part_ptr)
{
	sview_part_info_t *sview_part_info =
		xmalloc(sizeof(sview_part_info_t));


	sview_part_info->part_ptr = part_ptr;
	sview_part_info->sub_list = list_create(_destroy_part_sub);
	return sview_part_info;
}

static int _sview_part_sort_aval_dec(sview_part_info_t* rec_a,
				     sview_part_info_t* rec_b)
{

	partition_info_t *part_ptr = NULL;
	static node_info_msg_t *last_node_info_ptr = NULL;
	static partition_info_msg_t *last_part_info_ptr = NULL;
	List last_list = NULL;
	ListIterator last_list_itr = NULL;
	node_info_t *node_ptr = NULL;
	static List info_list = NULL;
	int i, j2;

	last_part_info_ptr = part_info_ptr;

	if (info_list)
		last_list = info_list;

	info_list = list_create(_part_info_list_del);
	if (!info_list) {
		g_print("malloc error\n");
		return NULL;
	}

	if (last_list)
		last_list_itr = list_iterator_create(last_list);
	for (i=0; i<part_info_ptr->record_count; i++) {
		part_ptr = &(part_info_ptr->partition_array[i]);


		if (!working_sview_config.show_hidden &&
		    part_ptr->flags & PART_FLAG_HIDDEN)
			continue;

		sview_part_info = NULL;

		if (last_list_itr) {
			while ((sview_part_info =
				list_next(last_list_itr))) {
				if (!strcmp(sview_part_info->part_name,
					    part_ptr->name)) {
					list_remove(last_list_itr);
					_part_info_free(sview_part_info);
					break;
				}
			}
			list_iterator_reset(last_list_itr);
		}

		if (!sview_part_info)
			sview_part_info = xmalloc(sizeof(sview_part_info_t));
		sview_part_info->part_name = xstrdup(part_ptr->name);
		sview_part_info->part_ptr = part_ptr;
		sview_part_info->sub_list = list_create(_destroy_part_sub);
		sview_part_info->pos = i;
		list_append(info_list, sview_part_info);
		sview_part_info->color_inx = i % sview_colors_cnt;

	}
	list_sort(info_list, (ListCmpF)_sview_part_sort_aval_dec);

	if (last_list) {
		list_iterator_destroy(last_list_itr);
		list_destroy(last_list);
	}

	return info_list;
}





	GtkTreeIter iter_ptr;
	bool iter_set;
	int pos;
	char *resv_name;
	reserve_info_t *resv_ptr;
} sview_resv_info_t;


	return type;
}

static void _resv_info_free(sview_resv_info_t *sview_resv_info)
{
	if (sview_resv_info) {
		xfree(sview_resv_info->resv_name);
	}
}

static void _resv_info_list_del(void *object)
{
	sview_resv_info_t *sview_resv_info = (sview_resv_info_t *)object;

	if (sview_resv_info) {
		_resv_info_free(sview_resv_info);
		xfree(sview_resv_info);
	}
}

{
	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
	static GtkTreeModel *last_model = NULL;
	reserve_info_t *resv_ptr = NULL;
	char *name = NULL;
	ListIterator itr = NULL;
	sview_resv_info_t *sview_resv_info = NULL;


	itr = list_iterator_create(info_list);
	while ((sview_resv_info = (sview_resv_info_t*) list_next(itr))) {
		resv_ptr = sview_resv_info->resv_ptr;

		/* This means the tree_store changed (added new column
		   or something). */
		if (last_model != model)

		if (sview_resv_info->iter_set) {
			gtk_tree_model_get(model, &sview_resv_info->iter_ptr,
					   SORTID_NAME, &name, -1);
			if (strcmp(name, sview_resv_info->resv_name)) {
				/* Bad pointer */
				sview_resv_info->iter_set = false;
				//g_print("bad resv iter pointer\n");
			}

			_update_resv_record(sview_resv_info,
					    GTK_TREE_STORE(model));
		} else {
			_append_resv_record(sview_resv_info,
					    GTK_TREE_STORE(model));
			sview_resv_info->iter_set = true;
			 * goto add */
			if (gtk_tree_model_get_iter(
				    model, &sview_resv_info->iter_ptr, path)) {
				do {
					/* search for the jobid and
					   check to see if it is in
					   the list */
					gtk_tree_model_get(
						model,
						&sview_resv_info->iter_ptr,
						SORTID_NAME,
						&name, -1);
					if (!strcmp(name, resv_ptr->name)) {
						/* update with new info */
						g_free(name);
						_update_resv_record(
							sview_resv_info,
							GTK_TREE_STORE(model));
						sview_resv_info->iter_set = 1;
						break;
					}
					g_free(name);
				} while (gtk_tree_model_iter_next(
						 model,
						 &sview_resv_info->iter_ptr));
			}

			if (!sview_resv_info->iter_set) {
				_append_resv_record(sview_resv_info,
						    GTK_TREE_STORE(model));
				sview_resv_info->iter_set = true;
			}
			gtk_tree_path_free(path);
		}
	}
	list_iterator_destroy(itr);

static List _create_resv_info_list(reserve_info_msg_t *resv_info_ptr)
{
	static List info_list = NULL;
	List last_list = NULL;
	ListIterator last_list_itr = NULL;
	int i = 0;
	static reserve_info_msg_t *last_resv_info_ptr = NULL;
	sview_resv_info_t *sview_resv_info_ptr = NULL;

	last_resv_info_ptr = resv_info_ptr;

	if (info_list)
		last_list = info_list;
	else
		info_list = list_create(_resv_info_list_del);

	info_list = list_create(_resv_info_list_del);
	if (!info_list) {
		g_print("malloc error\n");
		return NULL;
	}

	if (last_list)
		last_list_itr = list_iterator_create(last_list);
	for(i=0; i<resv_info_ptr->record_count; i++) {
		resv_ptr = &(resv_info_ptr->reservation_array[i]);

		sview_resv_info_ptr = NULL;

		if (last_list_itr) {
			while ((sview_resv_info_ptr =
				list_next(last_list_itr))) {
				if (!strcmp(sview_resv_info_ptr->resv_name,
					    resv_ptr->name)) {
					list_remove(last_list_itr);
					_resv_info_free(sview_resv_info_ptr);
					break;
				}
			}
			list_iterator_reset(last_list_itr);
		}
		if (!sview_resv_info_ptr)
			sview_resv_info_ptr =
				xmalloc(sizeof(sview_resv_info_t));
		sview_resv_info_ptr->pos = i;
		sview_resv_info_ptr->resv_ptr = resv_ptr;
		sview_resv_info_ptr->color_inx = i % sview_colors_cnt;

	list_sort(info_list,
		  (ListCmpF)_sview_resv_sort_aval_dec);

	if (last_list) {
		list_iterator_destroy(last_list_itr);
		list_destroy(last_list);
	}

update_color:
	return info_list;
}

Lines 299-304 typedef struct { Link Here

(-)a/src/sview/sview.h (+1 lines)
299	char *color;	299	char *color;
300	GtkTreeIter iter_ptr;	300	GtkTreeIter iter_ptr;
301	bool iter_set;	301	bool iter_set;
		302	char *node_name;
302	node_info_t *node_ptr;	303	node_info_t *node_ptr;
303	int pos;	304	int pos;
304	char *reason;	305	char *reason;

Return to ticket 345

Lines 55-60 typedef struct { Link Here

(-)a/src/sview/job_info.c (-41 / +45 lines)
55	int color_inx;	55	int color_inx;
56	GtkTreeIter iter_ptr;	56	GtkTreeIter iter_ptr;
57	bool iter_set;	57	bool iter_set;
		58	uint32_t job_id;
58	job_info_t *job_ptr;	59	job_info_t *job_ptr;
59	int node_cnt;	60	int node_cnt;
60	char *nodes;	61	char *nodes;
Lines 507-520 static char _read_file(const char f_name) Link Here
507	return buf;	508	return buf;
508	}	509	}
509		510
		511	static void _job_info_free(sview_job_info_t *sview_job_info)
		512	{
		513	if (sview_job_info) {
		514	xfree(sview_job_info->nodes);
		515	if (sview_job_info->step_list) {
		516	list_destroy(sview_job_info->step_list);
		517	sview_job_info->step_list = NULL;
		518	}
		519	}
		520	}
		521
510	static void _job_info_list_del(void *object)	522	static void _job_info_list_del(void *object)
511	{	523	{
512	sview_job_info_t sview_job_info = (sview_job_info_t )object;	524	sview_job_info_t sview_job_info = (sview_job_info_t )object;
513		525
514	if (sview_job_info) {	526	if (sview_job_info) {
515	xfree(sview_job_info->nodes);	527	_job_info_free(sview_job_info);
516	if (sview_job_info->step_list)
517	list_destroy(sview_job_info->step_list);
518	xfree(sview_job_info);	528	xfree(sview_job_info);
519	}	529	}
520	}	530	}
Lines 2587-2627 static void _update_info_job(List info_list, Link Here
2587	_update_job_record(sview_job_info,	2597	_update_job_record(sview_job_info,
2588	GTK_TREE_STORE(model));	2598	GTK_TREE_STORE(model));
2589	else {	2599	else {
2590	GtkTreePath *path = gtk_tree_path_new_first();	2600	_append_job_record(sview_job_info,
2591		2601	GTK_TREE_STORE(model));
2592	/* get the iter, or find out the list is empty	2602	sview_job_info->iter_set = true;
2593	* goto add */
2594	if (gtk_tree_model_get_iter(
2595	model, &sview_job_info->iter_ptr, path)) {
2596	do {
2597	/* search for the jobid and
2598	check to see if it is in
2599	the list */
2600	gtk_tree_model_get(
2601	model,
2602	&sview_job_info->iter_ptr,
2603	SORTID_JOBID,
2604	&jobid, -1);
2605	if (jobid == job_ptr->job_id) {
2606	/* update with new info */
2607	_update_job_record(
2608	sview_job_info,
2609	GTK_TREE_STORE(model));
2610	sview_job_info->iter_set = 1;
2611	break;
2612	}
2613	} while (gtk_tree_model_iter_next(
2614	model,
2615	&sview_job_info->iter_ptr));
2616	}
2617
2618	if (!sview_job_info->iter_set) {
2619	_append_job_record(sview_job_info,
2620	GTK_TREE_STORE(model));
2621	sview_job_info->iter_set = true;
2622	}
2623
2624	gtk_tree_path_free(path);
2625	}	2603	}
2626	}	2604	}
2627	list_iterator_destroy(itr);	2605	list_iterator_destroy(itr);
Lines 2659-2664 static List _create_job_info_list(job_info_msg_t *job_info_ptr, Link Here
2659	{	2637	{
2660	static List info_list = NULL;	2638	static List info_list = NULL;
2661	static List odd_info_list = NULL;	2639	static List odd_info_list = NULL;
		2640	List last_list = NULL;
		2641	ListIterator last_list_itr = NULL;
2662	static job_info_msg_t *last_job_info_ptr = NULL;	2642	static job_info_msg_t *last_job_info_ptr = NULL;
2663	static job_step_info_response_msg_t *last_step_info_ptr = NULL;	2643	static job_step_info_response_msg_t *last_step_info_ptr = NULL;
2664	int i = 0, j = 0;	2644	int i = 0, j = 0;
Lines 2677-2683 static List _create_job_info_list(job_info_msg_t *job_info_ptr, Link Here
2677		2657
2678	if (info_list) {	2658	if (info_list) {
2679	list_flush(info_list);	2659	list_flush(info_list);
2680	list_flush(odd_info_list);	2660	last_list = odd_info_list;
		2661	odd_info_list = list_create(_job_info_list_del);
2681	} else {	2662	} else {
2682	info_list = list_create(NULL);	2663	info_list = list_create(NULL);
2683	odd_info_list = list_create(_job_info_list_del);	2664	odd_info_list = list_create(_job_info_list_del);
Lines 2686-2697 static List _create_job_info_list(job_info_msg_t *job_info_ptr, Link Here
2686	g_print("malloc error\n");	2667	g_print("malloc error\n");
2687	return NULL;	2668	return NULL;
2688	}	2669	}
2689		2670	if (last_list)
		2671	last_list_itr = list_iterator_create(last_list);
2690	for (i=0; i<job_info_ptr->record_count; i++) {	2672	for (i=0; i<job_info_ptr->record_count; i++) {
2691	job_ptr = &(job_info_ptr->job_array[i]);	2673	job_ptr = &(job_info_ptr->job_array[i]);
2692		2674
2693	sview_job_info_ptr = xmalloc(sizeof(sview_job_info_t));	2675	sview_job_info_ptr = NULL;
		2676
		2677	if (last_list_itr) {
		2678	while ((sview_job_info_ptr =
		2679	list_next(last_list_itr))) {
		2680	if (sview_job_info_ptr->job_id ==
		2681	job_ptr->job_id) {
		2682	list_remove(last_list_itr);
		2683	_job_info_free(sview_job_info_ptr);
		2684	break;
		2685	}
		2686	}
		2687	list_iterator_reset(last_list_itr);
		2688	}
		2689
		2690	if (!sview_job_info_ptr)
		2691	sview_job_info_ptr = xmalloc(sizeof(sview_job_info_t));
2694	sview_job_info_ptr->job_ptr = job_ptr;	2692	sview_job_info_ptr->job_ptr = job_ptr;
		2693	sview_job_info_ptr->job_id = job_ptr->job_id;
2695	sview_job_info_ptr->step_list = list_create(NULL);	2694	sview_job_info_ptr->step_list = list_create(NULL);
2696	sview_job_info_ptr->pos = i;	2695	sview_job_info_ptr->pos = i;
2697	sview_job_info_ptr->node_cnt = 0;	2696	sview_job_info_ptr->node_cnt = 0;
Lines 2747-2752 static List _create_job_info_list(job_info_msg_t *job_info_ptr, Link Here
2747		2746
2748	list_sort(odd_info_list, (ListCmpF)_sview_job_sort_aval_dec);	2747	list_sort(odd_info_list, (ListCmpF)_sview_job_sort_aval_dec);
2749		2748
		2749	if (last_list) {
		2750	list_iterator_destroy(last_list_itr);
		2751	list_destroy(last_list);
		2752	}
		2753
2750	update_color:	2754	update_color:
2751		2755
2752	if (want_odd_states)	2756	if (want_odd_states)

Lines 548-554 static void _update_info_node(List info_list, GtkTreeView *tree_view) Link Here

(-)a/src/sview/node_info.c (-48 / +50 lines)
548	{	548	{
549	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);	549	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
550	static GtkTreeModel *last_model = NULL;	550	static GtkTreeModel *last_model = NULL;
551	node_info_t *node_ptr = NULL;
552	char *name;	551	char *name;
553	ListIterator itr = NULL;	552	ListIterator itr = NULL;
554	sview_node_info_t *sview_node_info = NULL;	553	sview_node_info_t *sview_node_info = NULL;
Lines 557-563 static void _update_info_node(List info_list, GtkTreeView *tree_view) Link Here
557		556
558	itr = list_iterator_create(info_list);	557	itr = list_iterator_create(info_list);
559	while ((sview_node_info = (sview_node_info_t*) list_next(itr))) {	558	while ((sview_node_info = (sview_node_info_t*) list_next(itr))) {
560	node_ptr = sview_node_info->node_ptr;
561		559
562	/* This means the tree_store changed (added new column	560	/* This means the tree_store changed (added new column
563	or something). */	561	or something). */
Lines 567-618 static void _update_info_node(List info_list, GtkTreeView *tree_view) Link Here
567	if (sview_node_info->iter_set) {	565	if (sview_node_info->iter_set) {
568	gtk_tree_model_get(model, &sview_node_info->iter_ptr,	566	gtk_tree_model_get(model, &sview_node_info->iter_ptr,
569	SORTID_NAME, &name, -1);	567	SORTID_NAME, &name, -1);
570	if (strcmp(name, node_ptr->name)) { /* Bad pointer */	568	if (strcmp(name, sview_node_info->node_name)) {
		569	/* Bad pointer */
571	sview_node_info->iter_set = false;	570	sview_node_info->iter_set = false;
572	//g_print("bad node iter pointer\n");	571	//g_print("bad node iter pointer\n");
573	}	572	}
574	g_free(name);	573	g_free(name);
575	}	574	}
576	if (sview_node_info->iter_set) {	575	if (sview_node_info->iter_set)
577	_update_node_record(sview_node_info,	576	_update_node_record(sview_node_info,
578	GTK_TREE_STORE(model));	577	GTK_TREE_STORE(model));
579	} else {	578	else {
580	GtkTreePath *path = gtk_tree_path_new_first();	579	_append_node_record(sview_node_info,
581		580	GTK_TREE_STORE(model));
582	/* get the iter, or find out the list is empty	581	sview_node_info->iter_set = true;
583	* goto add */
584	if (gtk_tree_model_get_iter(
585	model, &sview_node_info->iter_ptr, path)) {
586	do {
587	/* search for the node name and check
588	* to see if it is in the list */
589	gtk_tree_model_get(
590	model,
591	&sview_node_info->iter_ptr,
592	SORTID_NAME,
593	&name, -1);
594	if (name && node_ptr->name &&
595	!strcmp(name, node_ptr->name)) {
596	/* update with new info */
597	g_free(name);
598	_update_node_record(
599	sview_node_info,
600	GTK_TREE_STORE(model));
601	sview_node_info->iter_set = 1;
602	break;
603	}
604	g_free(name);
605	} while (gtk_tree_model_iter_next(
606	model,
607	&sview_node_info->iter_ptr));
608	}
609
610	if (!sview_node_info->iter_set) {
611	_append_node_record(sview_node_info,
612	GTK_TREE_STORE(model));
613	sview_node_info->iter_set = true;
614	}
615	gtk_tree_path_free(path);
616	}	582	}
617	}	583	}
618	list_iterator_destroy(itr);	584	list_iterator_destroy(itr);
Lines 622-636 static void _update_info_node(List info_list, GtkTreeView *tree_view) Link Here
622	last_model = model;	588	last_model = model;
623	}	589	}
624		590
625	static void _node_info_list_del(void *object)	591	static void _node_info_free(sview_node_info_t *sview_node_info)
626	{	592	{
627	sview_node_info_t sview_node_info = (sview_node_info_t )object;
628
629	if (sview_node_info) {	593	if (sview_node_info) {
630	xfree(sview_node_info->slurmd_start_time);	594	xfree(sview_node_info->slurmd_start_time);
631	xfree(sview_node_info->boot_time);	595	xfree(sview_node_info->boot_time);
		596	xfree(sview_node_info->node_name);
632	xfree(sview_node_info->rack_mp);	597	xfree(sview_node_info->rack_mp);
633	xfree(sview_node_info->reason);	598	xfree(sview_node_info->reason);
		599	}
		600	}
		601
		602	static void _node_info_list_del(void *object)
		603	{
		604	sview_node_info_t sview_node_info = (sview_node_info_t )object;
		605
		606	if (sview_node_info) {
		607	_node_info_free(sview_node_info);
634	xfree(sview_node_info);	608	xfree(sview_node_info);
635	}	609	}
636	}	610	}
Lines 757-762 extern List create_node_info_list(node_info_msg_t *node_info_ptr, Link Here
757	{	731	{
758	static List info_list = NULL;	732	static List info_list = NULL;
759	static node_info_msg_t *last_node_info_ptr = NULL;	733	static node_info_msg_t *last_node_info_ptr = NULL;
		734	List last_list = NULL;
		735	ListIterator last_list_itr = NULL;
760	int i = 0;	736	int i = 0;
761	sview_node_info_t *sview_node_info_ptr = NULL;	737	sview_node_info_t *sview_node_info_ptr = NULL;
762	node_info_t *node_ptr = NULL;	738	node_info_t *node_ptr = NULL;
Lines 771-784 extern List create_node_info_list(node_info_msg_t *node_info_ptr, Link Here
771	last_node_info_ptr = node_info_ptr;	747	last_node_info_ptr = node_info_ptr;
772		748
773	if (info_list)	749	if (info_list)
774	list_flush(info_list);	750	last_list = info_list;
775	else	751
776	info_list = list_create(_node_info_list_del);	752	info_list = list_create(_node_info_list_del);
777	if (!info_list) {	753	if (!info_list) {
778	g_print("malloc error\n");	754	g_print("malloc error\n");
779	return NULL;	755	return NULL;
780	}	756	}
781		757
		758	if (last_list)
		759	last_list_itr = list_iterator_create(last_list);
782	for (i=0; i<node_info_ptr->record_count; i++) {	760	for (i=0; i<node_info_ptr->record_count; i++) {
783	char *select_reason_str = NULL;	761	char *select_reason_str = NULL;
784	node_ptr = &(node_info_ptr->node_array[i]);	762	node_ptr = &(node_info_ptr->node_array[i]);
Lines 786-791 extern List create_node_info_list(node_info_msg_t *node_info_ptr, Link Here
786	if (!node_ptr->name \|\| (node_ptr->name[0] == '\0'))	764	if (!node_ptr->name \|\| (node_ptr->name[0] == '\0'))
787	continue;	765	continue;
788		766
		767	sview_node_info_ptr = NULL;
		768
		769	if (last_list_itr) {
		770	while ((sview_node_info_ptr =
		771	list_next(last_list_itr))) {
		772	if (!strcmp(sview_node_info_ptr->node_name,
		773	node_ptr->name)) {
		774	list_remove(last_list_itr);
		775	_node_info_free(sview_node_info_ptr);
		776	break;
		777	}
		778	}
		779	list_iterator_reset(last_list_itr);
		780	}
		781
789	/* constrain list to included partitions' nodes */	782	/* constrain list to included partitions' nodes */
790	/* and there are excluded values to process */	783	/* and there are excluded values to process */
791	/* and user has not requested to show hidden */	784	/* and user has not requested to show hidden */
Lines 794-801 extern List create_node_info_list(node_info_msg_t *node_info_ptr, Link Here
794	/* && !check_part_includes_node(i)) */	787	/* && !check_part_includes_node(i)) */
795	/* continue; */	788	/* continue; */
796		789
797	sview_node_info_ptr = xmalloc(sizeof(sview_node_info_t));	790	if (!sview_node_info_ptr)
		791	sview_node_info_ptr =
		792	xmalloc(sizeof(sview_node_info_t));
798	list_append(info_list, sview_node_info_ptr);	793	list_append(info_list, sview_node_info_ptr);
		794	sview_node_info_ptr->node_name = xstrdup(node_ptr->name);
799	sview_node_info_ptr->node_ptr = node_ptr;	795	sview_node_info_ptr->node_ptr = node_ptr;
800	sview_node_info_ptr->pos = i;	796	sview_node_info_ptr->pos = i;
801		797
Lines 846-851 extern List create_node_info_list(node_info_msg_t *node_info_ptr, Link Here
846	xstrdup(time_str);	842	xstrdup(time_str);
847	}	843	}
848	}	844	}
		845
		846	if (last_list) {
		847	list_iterator_destroy(last_list_itr);
		848	list_destroy(last_list);
		849	}
		850
849	update_color:	851	update_color:
850		852
851	return info_list;	853	return info_list;

Lines 57-62 typedef struct { Link Here

(-)a/src/sview/part_info.c (-62 / +49 lines)
57	int color_inx;	57	int color_inx;
58	GtkTreeIter iter_ptr;	58	GtkTreeIter iter_ptr;
59	bool iter_set;	59	bool iter_set;
		60	char *part_name;
60	/* part_info contains partition, avail, max_time, job_size,	61	/* part_info contains partition, avail, max_time, job_size,
61	* root, share, groups */	62	* root, share, groups */
62	partition_info_t* part_ptr;	63	partition_info_t* part_ptr;
Lines 1371-1377 static void _update_info_part(List info_list, Link Here
1371	{	1372	{
1372	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);	1373	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
1373	static GtkTreeModel *last_model = NULL;	1374	static GtkTreeModel *last_model = NULL;
1374	partition_info_t *part_ptr = NULL;
1375	char *name = NULL;	1375	char *name = NULL;
1376	ListIterator itr = NULL;	1376	ListIterator itr = NULL;
1377	sview_part_info_t *sview_part_info = NULL;	1377	sview_part_info_t *sview_part_info = NULL;
Lines 1380-1386 static void _update_info_part(List info_list, Link Here
1380		1380
1381	itr = list_iterator_create(info_list);	1381	itr = list_iterator_create(info_list);
1382	while ((sview_part_info = (sview_part_info_t*) list_next(itr))) {	1382	while ((sview_part_info = (sview_part_info_t*) list_next(itr))) {
1383	part_ptr = sview_part_info->part_ptr;
1384	/* This means the tree_store changed (added new column	1383	/* This means the tree_store changed (added new column
1385	or something). */	1384	or something). */
1386	if (last_model != model)	1385	if (last_model != model)
Lines 1389-1395 static void _update_info_part(List info_list, Link Here
1389	if (sview_part_info->iter_set) {	1388	if (sview_part_info->iter_set) {
1390	gtk_tree_model_get(model, &sview_part_info->iter_ptr,	1389	gtk_tree_model_get(model, &sview_part_info->iter_ptr,
1391	SORTID_NAME, &name, -1);	1390	SORTID_NAME, &name, -1);
1392	if (strcmp(name, part_ptr->name)) /* Bad pointer */	1391	if (strcmp(name, sview_part_info->part_name))
		1392	/* Bad pointer */
1393	sview_part_info->iter_set = false;	1393	sview_part_info->iter_set = false;
1394	g_free(name);	1394	g_free(name);
1395	}	1395	}
Lines 1397-1438 static void _update_info_part(List info_list, Link Here
1397	_update_part_record(sview_part_info,	1397	_update_part_record(sview_part_info,
1398	GTK_TREE_STORE(model));	1398	GTK_TREE_STORE(model));
1399	else {	1399	else {
1400	GtkTreePath *path = gtk_tree_path_new_first();	1400	_append_part_record(sview_part_info,
1401		1401	GTK_TREE_STORE(model));
1402	/* get the iter, or find out the list is empty	1402	sview_part_info->iter_set = true;
1403	* goto add */
1404	if (gtk_tree_model_get_iter(
1405	model, &sview_part_info->iter_ptr, path)) {
1406	do {
1407	/* search for the jobid and
1408	check to see if it is in
1409	the list */
1410	gtk_tree_model_get(
1411	model,
1412	&sview_part_info->iter_ptr,
1413	SORTID_NAME,
1414	&name, -1);
1415	if (!strcmp(name, part_ptr->name)) {
1416	/* update with new info */
1417	g_free(name);
1418	_update_part_record(
1419	sview_part_info,
1420	GTK_TREE_STORE(model));
1421	sview_part_info->iter_set = 1;
1422	break;
1423	}
1424	g_free(name);
1425	} while (gtk_tree_model_iter_next(
1426	model,
1427	&sview_part_info->iter_ptr));
1428	}
1429
1430	if (!sview_part_info->iter_set) {
1431	_append_part_record(sview_part_info,
1432	GTK_TREE_STORE(model));
1433	sview_part_info->iter_set = true;
1434	}
1435	gtk_tree_path_free(path);
1436	}	1403	}
1437	}	1404	}
1438	list_iterator_destroy(itr);	1405	list_iterator_destroy(itr);
Lines 1442-1454 static void _update_info_part(List info_list, Link Here
1442	return;	1409	return;
1443	}	1410	}
1444		1411
		1412	static void _part_info_free(sview_part_info_t *sview_part_info)
		1413	{
		1414	if (sview_part_info) {
		1415	xfree(sview_part_info->part_name);
		1416	if (sview_part_info->sub_list)
		1417	list_destroy(sview_part_info->sub_list);
		1418	}
		1419	}
		1420
1445	static void _part_info_list_del(void *object)	1421	static void _part_info_list_del(void *object)
1446	{	1422	{
1447	sview_part_info_t sview_part_info = (sview_part_info_t )object;	1423	sview_part_info_t sview_part_info = (sview_part_info_t )object;
1448		1424
1449	if (sview_part_info) {	1425	if (sview_part_info) {
1450	if (sview_part_info->sub_list)	1426	_part_info_free(sview_part_info);
1451	list_destroy(sview_part_info->sub_list);
1452	xfree(sview_part_info);	1427	xfree(sview_part_info);
1453	}	1428	}
1454	}	1429	}
Lines 1595-1617 static int _insert_sview_part_sub(sview_part_info_t *sview_part_info, Link Here
1595	return SLURM_SUCCESS;	1570	return SLURM_SUCCESS;
1596	}	1571	}
1597		1572
1598	/*
1599	* _create_sview_part_info - create an sview_part_info record for
1600	* the given partition
1601	* part_ptr IN - pointer to partition record to add
1602	* sview_part_info OUT - ptr to an inited sview_part_info_t
1603	*/
1604	static sview_part_info_t _create_sview_part_info(partition_info_t part_ptr)
1605	{
1606	sview_part_info_t *sview_part_info =
1607	xmalloc(sizeof(sview_part_info_t));
1608
1609
1610	sview_part_info->part_ptr = part_ptr;
1611	sview_part_info->sub_list = list_create(_destroy_part_sub);
1612	return sview_part_info;
1613	}
1614
1615	static int _sview_part_sort_aval_dec(sview_part_info_t* rec_a,	1573	static int _sview_part_sort_aval_dec(sview_part_info_t* rec_a,
1616	sview_part_info_t* rec_b)	1574	sview_part_info_t* rec_b)
1617	{	1575	{
Lines 1653-1658 static List _create_part_info_list(partition_info_msg_t *part_info_ptr, Link Here
1653	partition_info_t *part_ptr = NULL;	1611	partition_info_t *part_ptr = NULL;
1654	static node_info_msg_t *last_node_info_ptr = NULL;	1612	static node_info_msg_t *last_node_info_ptr = NULL;
1655	static partition_info_msg_t *last_part_info_ptr = NULL;	1613	static partition_info_msg_t *last_part_info_ptr = NULL;
		1614	List last_list = NULL;
		1615	ListIterator last_list_itr = NULL;
1656	node_info_t *node_ptr = NULL;	1616	node_info_t *node_ptr = NULL;
1657	static List info_list = NULL;	1617	static List info_list = NULL;
1658	int i, j2;	1618	int i, j2;
Lines 1667-1680 static List _create_part_info_list(partition_info_msg_t *part_info_ptr, Link Here
1667	last_part_info_ptr = part_info_ptr;	1627	last_part_info_ptr = part_info_ptr;
1668		1628
1669	if (info_list)	1629	if (info_list)
1670	list_flush(info_list);	1630	last_list = info_list;
1671	else	1631
1672	info_list = list_create(_part_info_list_del);	1632	info_list = list_create(_part_info_list_del);
1673	if (!info_list) {	1633	if (!info_list) {
1674	g_print("malloc error\n");	1634	g_print("malloc error\n");
1675	return NULL;	1635	return NULL;
1676	}	1636	}
1677		1637
		1638	if (last_list)
		1639	last_list_itr = list_iterator_create(last_list);
1678	for (i=0; i<part_info_ptr->record_count; i++) {	1640	for (i=0; i<part_info_ptr->record_count; i++) {
1679	part_ptr = &(part_info_ptr->partition_array[i]);	1641	part_ptr = &(part_info_ptr->partition_array[i]);
1680		1642
Lines 1682-1688 static List _create_part_info_list(partition_info_msg_t *part_info_ptr, Link Here
1682	if (!working_sview_config.show_hidden &&	1644	if (!working_sview_config.show_hidden &&
1683	part_ptr->flags & PART_FLAG_HIDDEN)	1645	part_ptr->flags & PART_FLAG_HIDDEN)
1684	continue;	1646	continue;
1685	sview_part_info = _create_sview_part_info(part_ptr);	1647
		1648	sview_part_info = NULL;
		1649
		1650	if (last_list_itr) {
		1651	while ((sview_part_info =
		1652	list_next(last_list_itr))) {
		1653	if (!strcmp(sview_part_info->part_name,
		1654	part_ptr->name)) {
		1655	list_remove(last_list_itr);
		1656	_part_info_free(sview_part_info);
		1657	break;
		1658	}
		1659	}
		1660	list_iterator_reset(last_list_itr);
		1661	}
		1662
		1663	if (!sview_part_info)
		1664	sview_part_info = xmalloc(sizeof(sview_part_info_t));
		1665	sview_part_info->part_name = xstrdup(part_ptr->name);
		1666	sview_part_info->part_ptr = part_ptr;
		1667	sview_part_info->sub_list = list_create(_destroy_part_sub);
1686	sview_part_info->pos = i;	1668	sview_part_info->pos = i;
1687	list_append(info_list, sview_part_info);	1669	list_append(info_list, sview_part_info);
1688	sview_part_info->color_inx = i % sview_colors_cnt;	1670	sview_part_info->color_inx = i % sview_colors_cnt;
Lines 1736-1741 static List _create_part_info_list(partition_info_msg_t *part_info_ptr, Link Here
1736	}	1718	}
1737	list_sort(info_list, (ListCmpF)_sview_part_sort_aval_dec);	1719	list_sort(info_list, (ListCmpF)_sview_part_sort_aval_dec);
1738		1720
		1721	if (last_list) {
		1722	list_iterator_destroy(last_list_itr);
		1723	list_destroy(last_list);
		1724	}
		1725
1739	return info_list;	1726	return info_list;
1740	}	1727	}
1741		1728

Lines 38-43 typedef struct { Link Here

(-)a/src/sview/resv_info.c (-44 / +42 lines)
38	GtkTreeIter iter_ptr;	38	GtkTreeIter iter_ptr;
39	bool iter_set;	39	bool iter_set;
40	int pos;	40	int pos;
		41	char *resv_name;
41	reserve_info_t *resv_ptr;	42	reserve_info_t *resv_ptr;
42	} sview_resv_info_t;	43	} sview_resv_info_t;
43		44
Lines 416-426 return_error: Link Here
416	return type;	417	return type;
417	}	418	}
418		419
		420	static void _resv_info_free(sview_resv_info_t *sview_resv_info)
		421	{
		422	if (sview_resv_info) {
		423	xfree(sview_resv_info->resv_name);
		424	}
		425	}
		426
419	static void _resv_info_list_del(void *object)	427	static void _resv_info_list_del(void *object)
420	{	428	{
421	sview_resv_info_t sview_resv_info = (sview_resv_info_t )object;	429	sview_resv_info_t sview_resv_info = (sview_resv_info_t )object;
422		430
423	if (sview_resv_info) {	431	if (sview_resv_info) {
		432	_resv_info_free(sview_resv_info);
424	xfree(sview_resv_info);	433	xfree(sview_resv_info);
425	}	434	}
426	}	435	}
Lines 665-671 static void _update_info_resv(List info_list, Link Here
665	{	674	{
666	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);	675	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
667	static GtkTreeModel *last_model = NULL;	676	static GtkTreeModel *last_model = NULL;
668	reserve_info_t *resv_ptr = NULL;
669	char *name = NULL;	677	char *name = NULL;
670	ListIterator itr = NULL;	678	ListIterator itr = NULL;
671	sview_resv_info_t *sview_resv_info = NULL;	679	sview_resv_info_t *sview_resv_info = NULL;
Lines 674-681 static void _update_info_resv(List info_list, Link Here
674		682
675	itr = list_iterator_create(info_list);	683	itr = list_iterator_create(info_list);
676	while ((sview_resv_info = (sview_resv_info_t*) list_next(itr))) {	684	while ((sview_resv_info = (sview_resv_info_t*) list_next(itr))) {
677	resv_ptr = sview_resv_info->resv_ptr;
678
679	/* This means the tree_store changed (added new column	685	/* This means the tree_store changed (added new column
680	or something). */	686	or something). */
681	if (last_model != model)	687	if (last_model != model)
Lines 684-690 static void _update_info_resv(List info_list, Link Here
684	if (sview_resv_info->iter_set) {	690	if (sview_resv_info->iter_set) {
685	gtk_tree_model_get(model, &sview_resv_info->iter_ptr,	691	gtk_tree_model_get(model, &sview_resv_info->iter_ptr,
686	SORTID_NAME, &name, -1);	692	SORTID_NAME, &name, -1);
687	if (strcmp(name, resv_ptr->name)) { /* Bad pointer */	693	if (strcmp(name, sview_resv_info->resv_name)) {
		694	/* Bad pointer */
688	sview_resv_info->iter_set = false;	695	sview_resv_info->iter_set = false;
689	//g_print("bad resv iter pointer\n");	696	//g_print("bad resv iter pointer\n");
690	}	697	}
Lines 694-735 static void _update_info_resv(List info_list, Link Here
694	_update_resv_record(sview_resv_info,	701	_update_resv_record(sview_resv_info,
695	GTK_TREE_STORE(model));	702	GTK_TREE_STORE(model));
696	} else {	703	} else {
697	GtkTreePath *path = gtk_tree_path_new_first();	704	_append_resv_record(sview_resv_info,
698		705	GTK_TREE_STORE(model));
699	/* get the iter, or find out the list is empty	706	sview_resv_info->iter_set = true;
700	* goto add */
701	if (gtk_tree_model_get_iter(
702	model, &sview_resv_info->iter_ptr, path)) {
703	do {
704	/* search for the jobid and
705	check to see if it is in
706	the list */
707	gtk_tree_model_get(
708	model,
709	&sview_resv_info->iter_ptr,
710	SORTID_NAME,
711	&name, -1);
712	if (!strcmp(name, resv_ptr->name)) {
713	/* update with new info */
714	g_free(name);
715	_update_resv_record(
716	sview_resv_info,
717	GTK_TREE_STORE(model));
718	sview_resv_info->iter_set = 1;
719	break;
720	}
721	g_free(name);
722	} while (gtk_tree_model_iter_next(
723	model,
724	&sview_resv_info->iter_ptr));
725	}
726
727	if (!sview_resv_info->iter_set) {
728	_append_resv_record(sview_resv_info,
729	GTK_TREE_STORE(model));
730	sview_resv_info->iter_set = true;
731	}
732	gtk_tree_path_free(path);
733	}	707	}
734	}	708	}
735	list_iterator_destroy(itr);	709	list_iterator_destroy(itr);
Lines 764-769 static int _sview_resv_sort_aval_dec(sview_resv_info_t* rec_a, Link Here
764	static List _create_resv_info_list(reserve_info_msg_t *resv_info_ptr)	738	static List _create_resv_info_list(reserve_info_msg_t *resv_info_ptr)
765	{	739	{
766	static List info_list = NULL;	740	static List info_list = NULL;
		741	List last_list = NULL;
		742	ListIterator last_list_itr = NULL;
767	int i = 0;	743	int i = 0;
768	static reserve_info_msg_t *last_resv_info_ptr = NULL;	744	static reserve_info_msg_t *last_resv_info_ptr = NULL;
769	sview_resv_info_t *sview_resv_info_ptr = NULL;	745	sview_resv_info_t *sview_resv_info_ptr = NULL;
Lines 775-793 static List _create_resv_info_list(reserve_info_msg_t *resv_info_ptr) Link Here
775	last_resv_info_ptr = resv_info_ptr;	751	last_resv_info_ptr = resv_info_ptr;
776		752
777	if (info_list)	753	if (info_list)
778	list_flush(info_list);	754	last_list = info_list;
779	else
780	info_list = list_create(_resv_info_list_del);
781		755
		756	info_list = list_create(_resv_info_list_del);
782	if (!info_list) {	757	if (!info_list) {
783	g_print("malloc error\n");	758	g_print("malloc error\n");
784	return NULL;	759	return NULL;
785	}	760	}
786		761
		762	if (last_list)
		763	last_list_itr = list_iterator_create(last_list);
787	for(i=0; i<resv_info_ptr->record_count; i++) {	764	for(i=0; i<resv_info_ptr->record_count; i++) {
788	resv_ptr = &(resv_info_ptr->reservation_array[i]);	765	resv_ptr = &(resv_info_ptr->reservation_array[i]);
789		766
790	sview_resv_info_ptr = xmalloc(sizeof(sview_resv_info_t));	767	sview_resv_info_ptr = NULL;
		768
		769	if (last_list_itr) {
		770	while ((sview_resv_info_ptr =
		771	list_next(last_list_itr))) {
		772	if (!strcmp(sview_resv_info_ptr->resv_name,
		773	resv_ptr->name)) {
		774	list_remove(last_list_itr);
		775	_resv_info_free(sview_resv_info_ptr);
		776	break;
		777	}
		778	}
		779	list_iterator_reset(last_list_itr);
		780	}
		781	if (!sview_resv_info_ptr)
		782	sview_resv_info_ptr =
		783	xmalloc(sizeof(sview_resv_info_t));
791	sview_resv_info_ptr->pos = i;	784	sview_resv_info_ptr->pos = i;
792	sview_resv_info_ptr->resv_ptr = resv_ptr;	785	sview_resv_info_ptr->resv_ptr = resv_ptr;
793	sview_resv_info_ptr->color_inx = i % sview_colors_cnt;	786	sview_resv_info_ptr->color_inx = i % sview_colors_cnt;
Lines 797-802 static List _create_resv_info_list(reserve_info_msg_t *resv_info_ptr) Link Here
797	list_sort(info_list,	790	list_sort(info_list,
798	(ListCmpF)_sview_resv_sort_aval_dec);	791	(ListCmpF)_sview_resv_sort_aval_dec);
799		792
		793	if (last_list) {
		794	list_iterator_destroy(last_list_itr);
		795	list_destroy(last_list);
		796	}
		797
800	update_color:	798	update_color:
801	return info_list;	799	return info_list;
802	}	800	}

Lines 223-232 static char *_set_running_job_str(List job_list, bool compact) Link Here

(-)a/src/sview/block_info.c (-45 / +42 lines)
223	return NULL;	223	return NULL;
224	}	224	}
225		225
226	static void _block_list_del(void *object)	226	static void _block_info_free(sview_block_info_t *block_ptr)
227	{	227	{
228	sview_block_info_t block_ptr = (sview_block_info_t )object;
229
230	if (block_ptr) {	228	if (block_ptr) {
231	xfree(block_ptr->bg_block_name);	229	xfree(block_ptr->bg_block_name);
232	xfree(block_ptr->slurm_part_name);	230	xfree(block_ptr->slurm_part_name);
Lines 245-252 static void _block_list_del(void *object) Link Here
245	/* don't xfree(block_ptr->mp_inx);	243	/* don't xfree(block_ptr->mp_inx);
246	it isn't copied like the chars and is freed in the api	244	it isn't copied like the chars and is freed in the api
247	*/	245	*/
248	xfree(block_ptr);	246	}
		247	}
249		248
		249	static void _block_list_del(void *object)
		250	{
		251	sview_block_info_t block_ptr = (sview_block_info_t )object;
		252
		253	if (block_ptr) {
		254	_block_info_free(block_ptr);
		255	xfree(block_ptr);
250	}	256	}
251	}	257	}
252		258
Lines 485-527 static void _update_info_block(List block_list, Link Here
485	_update_block_record(block_ptr,	491	_update_block_record(block_ptr,
486	GTK_TREE_STORE(model));	492	GTK_TREE_STORE(model));
487	else {	493	else {
488	GtkTreePath *path = gtk_tree_path_new_first();	494	_append_block_record(block_ptr,
489		495	GTK_TREE_STORE(model));
490	/* get the iter, or find out the list is empty	496	block_ptr->iter_set = true;
491	* goto add */
492	if (gtk_tree_model_get_iter(
493	model, &block_ptr->iter_ptr, path)) {
494	do {
495	/* search for the jobid and
496	check to see if it is in
497	the list */
498	gtk_tree_model_get(
499	model,
500	&block_ptr->iter_ptr,
501	SORTID_BLOCK,
502	&name, -1);
503	if (!strcmp(name,
504	block_ptr->bg_block_name)) {
505	/* update with new info */
506	g_free(name);
507	_update_block_record(
508	block_ptr,
509	GTK_TREE_STORE(model));
510	block_ptr->iter_set = 1;
511	break;
512	}
513	g_free(name);
514	} while (gtk_tree_model_iter_next(
515	model,
516	&block_ptr->iter_ptr));
517	}
518
519	if (!block_ptr->iter_set) {
520	_append_block_record(block_ptr,
521	GTK_TREE_STORE(model));
522	block_ptr->iter_set = true;
523	}
524	gtk_tree_path_free(path);
525	}	497	}
526	}	498	}
527		499
Lines 588-593 static List _create_block_list(partition_info_msg_t *part_info_ptr, Link Here
588	static List block_list = NULL;	560	static List block_list = NULL;
589	static partition_info_msg_t *last_part_info_ptr = NULL;	561	static partition_info_msg_t *last_part_info_ptr = NULL;
590	static block_info_msg_t *last_block_info_ptr = NULL;	562	static block_info_msg_t *last_block_info_ptr = NULL;
		563	List last_list = NULL;
		564	ListIterator last_list_itr = NULL;
591	sview_block_info_t *block_ptr = NULL;	565	sview_block_info_t *block_ptr = NULL;
592	char tmp_mp_str[50];	566	char tmp_mp_str[50];
593		567
Lines 608-616 static List _create_block_list(partition_info_msg_t *part_info_ptr, Link Here
608		582
609	return block_list;	583	return block_list;
610	}	584	}
611	list_flush(block_list);	585	last_list = block_list;
612	} else	586	}
613	block_list = list_create(_block_list_del);	587
		588	block_list = list_create(_block_list_del);
614	if (!block_list) {	589	if (!block_list) {
615	g_print("malloc error\n");	590	g_print("malloc error\n");
616	return NULL;	591	return NULL;
Lines 618-630 static List _create_block_list(partition_info_msg_t *part_info_ptr, Link Here
618		593
619	last_block_info_ptr = block_info_ptr;	594	last_block_info_ptr = block_info_ptr;
620		595
		596	if (last_list)
		597	last_list_itr = list_iterator_create(last_list);
621	for (i=0; i<block_info_ptr->record_count; i++) {	598	for (i=0; i<block_info_ptr->record_count; i++) {
622	/* If we don't have a block name just continue since	599	/* If we don't have a block name just continue since
623	ths block hasn't been made in the system yet. */	600	ths block hasn't been made in the system yet. */
624	if (!block_info_ptr->block_array[i].bg_block_id)	601	if (!block_info_ptr->block_array[i].bg_block_id)
625	continue;	602	continue;
626		603
627	block_ptr = xmalloc(sizeof(sview_block_info_t));	604	block_ptr = NULL;
		605
		606	if (last_list_itr) {
		607	while ((block_ptr = list_next(last_list_itr))) {
		608	if (!strcmp(block_ptr->bg_block_name,
		609	block_info_ptr->
		610	block_array[i].bg_block_id)) {
		611	list_remove(last_list_itr);
		612	_block_info_free(block_ptr);
		613	break;
		614	}
		615	}
		616	list_iterator_reset(last_list_itr);
		617	}
		618
		619	if (!block_ptr)
		620	block_ptr = xmalloc(sizeof(sview_block_info_t));
628	block_ptr->pos = i;	621	block_ptr->pos = i;
629	block_ptr->bg_block_name	622	block_ptr->bg_block_name
630	= xstrdup(block_info_ptr->	623	= xstrdup(block_info_ptr->
Lines 706-711 static List _create_block_list(partition_info_msg_t *part_info_ptr, Link Here
706	list_sort(block_list,	699	list_sort(block_list,
707	(ListCmpF)_sview_block_sort_aval_dec);	700	(ListCmpF)_sview_block_sort_aval_dec);
708		701
		702	if (last_list) {
		703	list_iterator_destroy(last_list_itr);
		704	list_destroy(last_list);
		705	}
709		706
710	return block_list;	707	return block_list;
711	}	708	}