fru_access.c revision af3025fd013117424096c94bd9e116ecc538cc6b
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26#pragma ident	"%Z%%M%	%I%	%E% SMI"
27
28#include <limits.h>
29#include <alloca.h>
30#include "fru_access_impl.h"
31
32#pragma init(initialize_fruaccess)	/* .init section */
33
34static	hash_obj_t	*hash_table[TABLE_SIZE];
35
36/*
37 * seeprom is the driver_name for the SEEPROM device drivers in excalibur
38 * Define the devfsadm command to load the seeprom drivers if open fails.
39 */
40
41static	char	devfsadm_cmd[] = "/usr/sbin/devfsadm -i seeprom";
42
43/* this routine initialize the hash table. */
44
45static void
46initialize_fruaccess(void)
47{
48	int	count;
49	for (count = 0; count < TABLE_SIZE; count++) {
50		hash_table[count] = NULL;
51	}
52}
53
54/*
55 * called to lookup hash object for specified handle in the hash table.
56 *
57 */
58
59static hash_obj_t *
60lookup_handle_object(handle_t	handle, int object_type)
61{
62	handle_t	index_to_hash;
63	hash_obj_t	*first_hash_obj;
64	hash_obj_t	*next_hash_obj;
65
66	index_to_hash	= (handle % TABLE_SIZE);
67
68	first_hash_obj = hash_table[index_to_hash];
69	for (next_hash_obj = first_hash_obj; next_hash_obj != NULL;
70	    next_hash_obj = next_hash_obj->next) {
71		if ((handle == next_hash_obj->obj_hdl) &&
72		    (object_type == next_hash_obj->object_type)) {
73			return (next_hash_obj);
74		}
75	}
76	return (NULL);
77}
78
79/* called to allocate container hash object */
80
81static hash_obj_t *
82create_container_hash_object(void)
83{
84	hash_obj_t		*hash_obj;
85	container_obj_t		*cont_obj;
86
87	cont_obj	= malloc(sizeof (container_obj_t));
88	if (cont_obj == NULL) {
89		return (NULL);
90	}
91
92	hash_obj = malloc(sizeof (hash_obj_t));
93	if (hash_obj == NULL) {
94		free(cont_obj);
95		return (NULL);
96	}
97
98	cont_obj->sec_obj_list	= NULL;
99
100	hash_obj->object_type	= CONTAINER_TYPE;
101	hash_obj->u.cont_obj	= cont_obj;
102	hash_obj->next	= NULL;
103	hash_obj->prev	= NULL;
104
105	return (hash_obj);
106}
107
108/* called to allocate section hash object */
109
110static hash_obj_t *
111create_section_hash_object(void)
112{
113	hash_obj_t		*hash_obj;
114	section_obj_t		*sec_obj;
115
116	sec_obj	= malloc(sizeof (section_obj_t));
117	if (sec_obj == NULL) {
118		return (NULL);
119	}
120
121	hash_obj = malloc(sizeof (hash_obj_t));
122	if (hash_obj == NULL) {
123		free(sec_obj);
124		return (NULL);
125	}
126
127	sec_obj->next		= NULL;
128	sec_obj->seg_obj_list	= NULL;
129
130	hash_obj->u.sec_obj	= sec_obj;
131	hash_obj->object_type	= SECTION_TYPE;
132	hash_obj->next		= NULL;
133	hash_obj->prev		= NULL;
134
135	return (hash_obj);
136}
137
138/* called to allocate segment hash object */
139
140static hash_obj_t *
141create_segment_hash_object(void)
142{
143	hash_obj_t		*hash_obj;
144	segment_obj_t		*seg_obj;
145
146	seg_obj	= malloc(sizeof (segment_obj_t));
147	if (seg_obj == NULL) {
148		return (NULL);
149	}
150
151	hash_obj = malloc(sizeof (hash_obj_t));
152	if (hash_obj == NULL) {
153		free(seg_obj);
154		return (NULL);
155	}
156
157	seg_obj->next		= NULL;
158	seg_obj->pkt_obj_list	= NULL;
159
160	hash_obj->object_type	= SEGMENT_TYPE;
161	hash_obj->u.seg_obj	= seg_obj;
162	hash_obj->next		= NULL;
163	hash_obj->prev		= NULL;
164
165	return (hash_obj);
166}
167
168/* called to allocate packet hash object */
169
170static hash_obj_t *
171create_packet_hash_object(void)
172{
173	hash_obj_t		*hash_obj;
174	packet_obj_t		*pkt_obj;
175
176	pkt_obj	= malloc(sizeof (packet_obj_t));
177	if (pkt_obj == NULL) {
178		return (NULL);
179	}
180
181	hash_obj	= malloc(sizeof (hash_obj_t));
182	if (hash_obj == NULL) {
183		free(pkt_obj);
184		return (NULL);
185	}
186
187	pkt_obj->next		= NULL;
188
189	hash_obj->object_type	= PACKET_TYPE;
190	hash_obj->u.pkt_obj	= pkt_obj;
191	hash_obj->next		= NULL;
192	hash_obj->prev		= NULL;
193
194	return (hash_obj);
195}
196
197/* called to add allocated hash object into the hash table */
198
199static void
200add_hashobject_to_hashtable(hash_obj_t *hash_obj)
201{
202	handle_t		index_to_hash;
203	static	uint64_t	handle_count	= 0;
204
205	hash_obj->obj_hdl = ++handle_count;	/* store the handle */
206
207	/* where to add ? */
208	index_to_hash	= ((hash_obj->obj_hdl) % TABLE_SIZE);
209
210	hash_obj->next	= hash_table[index_to_hash];
211	hash_table[index_to_hash] = hash_obj;	/* hash obj. added */
212
213	if (hash_obj->next != NULL) {
214		hash_obj->next->prev = hash_obj;
215	}
216}
217
218/* called to add section object list into the section list */
219
220static void
221add_to_sec_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
222{
223	hash_obj_t	*next_hash;
224
225	child_obj->u.sec_obj->cont_hdl = parent_obj->obj_hdl;
226	if (parent_obj->u.cont_obj->sec_obj_list == NULL) {
227		parent_obj->u.cont_obj->sec_obj_list = child_obj;
228		return;
229	}
230
231	for (next_hash = parent_obj->u.cont_obj->sec_obj_list;
232	    next_hash->u.sec_obj->next != NULL;
233	    next_hash = next_hash->u.sec_obj->next) {
234		;
235	}
236
237	next_hash->u.sec_obj->next	= child_obj;
238}
239
240/* called to add segment object list into segment list */
241
242static void
243add_to_seg_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
244{
245	hash_obj_t	*next_hash;
246
247	child_obj->u.seg_obj->section_hdl = parent_obj->obj_hdl;
248	if (parent_obj->u.sec_obj->seg_obj_list == NULL) {
249		parent_obj->u.sec_obj->seg_obj_list = child_obj;
250		return;
251	}
252
253	for (next_hash = parent_obj->u.sec_obj->seg_obj_list;
254	    next_hash->u.seg_obj->next != NULL;
255	    next_hash = next_hash->u.seg_obj->next) {
256		;
257	}
258
259	next_hash->u.seg_obj->next	= child_obj;
260}
261
262/* called to add packet object list into packet list */
263
264static void
265add_to_pkt_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
266{
267	hash_obj_t	*next_hash;
268
269	/* add the packet object in the end of list */
270	child_obj->u.pkt_obj->segment_hdl = parent_obj->obj_hdl;
271
272	if (parent_obj->u.seg_obj->pkt_obj_list == NULL) {
273		parent_obj->u.seg_obj->pkt_obj_list = child_obj;
274		return;
275	}
276
277	for (next_hash = parent_obj->u.seg_obj->pkt_obj_list;
278	    next_hash->u.pkt_obj->next != NULL;
279	    next_hash = next_hash->u.pkt_obj->next) {
280		;
281	}
282
283	next_hash->u.pkt_obj->next = child_obj;
284}
285
286static void
287copy_segment_layout(segment_t	*seghdr, void	*layout)
288{
289	segment_layout_t	*seg_layout;
290
291	seg_layout	= (segment_layout_t *)layout;
292	(void) memcpy(seghdr->name, &seg_layout->name, SEG_NAME_LEN);
293	seghdr->descriptor = GET_SEGMENT_DESCRIPTOR;
294	seghdr->offset	= seg_layout->offset;
295	seghdr->length	= seg_layout->length;
296}
297
298static hash_obj_t *
299get_container_hash_object(int	object_type, handle_t	handle)
300{
301	hash_obj_t	*hash_obj;
302
303	switch (object_type) {
304	case	CONTAINER_TYPE	:
305		break;
306	case	SECTION_TYPE	:
307		hash_obj = lookup_handle_object(handle, CONTAINER_TYPE);
308		if (hash_obj == NULL) {
309			return (NULL);
310		}
311		break;
312	case	SEGMENT_TYPE	:
313		hash_obj = lookup_handle_object(handle, SECTION_TYPE);
314		if (hash_obj == NULL) {
315			return (NULL);
316		}
317		hash_obj = lookup_handle_object(hash_obj->u.sec_obj->cont_hdl,
318		    CONTAINER_TYPE);
319		break;
320	case	PACKET_TYPE	:
321		break;
322	default	:
323		return (NULL);
324	}
325	return (hash_obj);
326}
327
328
329static void
330sort_offsettbl(int	segcnt, seg_info_t	*offset_tbl)
331{
332	int		cntx;
333	int		cnty;
334	seg_info_t	tmp;
335
336	for (cntx = 0; cntx < segcnt+2; cntx++) {
337		for (cnty = cntx+1; cnty < segcnt + 2; cnty++) {
338			if (offset_tbl[cntx].offset >
339			    offset_tbl[cnty].offset) {
340				(void) memcpy(&tmp, &offset_tbl[cnty],
341				    sizeof (seg_info_t));
342				(void) memcpy(&offset_tbl[cnty],
343				    &offset_tbl[cntx], sizeof (seg_info_t));
344
345				(void) memcpy(&offset_tbl[cntx], &tmp,
346				    sizeof (seg_info_t));
347			}
348		}
349	}
350}
351
352/*
353 * Description : move_segment_data() reads the segment data and writes it
354 *      back to the new segment offset.
355 */
356
357static void
358move_segment_data(void *seghdr, int newoffset, container_hdl_t contfd)
359{
360	int			ret;
361	char			*buffer;
362	segment_layout_t	*segment;
363
364	segment	= (segment_layout_t *)seghdr;
365
366	buffer = alloca(segment->length);
367	if (buffer == NULL) {
368		return;
369	}
370
371	ret = pread(contfd, buffer, segment->length, segment->offset);
372	if (ret != segment->length) {
373		return;
374	}
375
376	segment->offset = newoffset;
377
378	ret = pwrite(contfd, buffer, segment->length, segment->offset);
379	if (ret != segment->length) {
380		return;
381	}
382}
383
384/*
385 * Description : pack_segment_data() moves the segment data if there is
386 *              a hole between two segments.
387 */
388
389static void
390pack_segment_data(char *seghdr, int segcnt, container_hdl_t contfd,
391    seg_info_t *offset_tbl)
392{
393	int	cnt;
394	int	diff;
395	int	newoffset;
396
397	for (cnt = segcnt + 1; cnt > 0; cnt--) {
398		if (!offset_tbl[cnt - 1].fixed) {
399			if (offset_tbl[cnt].offset -
400			    (offset_tbl[cnt -1 ].offset +
401			    offset_tbl[cnt - 1].length) > 0) {
402
403				diff = offset_tbl[cnt].offset -
404				    (offset_tbl[cnt - 1].offset +
405				    offset_tbl[cnt - 1].length);
406				newoffset = offset_tbl[cnt - 1].offset + diff;
407
408				move_segment_data(seghdr, newoffset, contfd);
409
410				offset_tbl[cnt - 1].offset = newoffset;
411
412				sort_offsettbl(segcnt, offset_tbl);
413			}
414		}
415	}
416}
417
418/*
419 * Description : build_offset_tbl() builds the offset table by reading all the
420 *              segment header. it makes two more entry into the table one for
421 *              section size and another with start of the section after the
422 *              segment header.
423 */
424
425static int
426build_offset_tbl(void   *seghdr, int segcnt, int secsize,
427    seg_info_t *offset_tbl)
428{
429	int			cnt;
430	fru_segdesc_t		segdesc;
431	segment_layout_t	*segment;
432
433	for (cnt = 0; cnt < segcnt; cnt++) {
434		segment	= (segment_layout_t *)(seghdr) + cnt;
435
436		(void) memcpy(&segdesc, &segment->descriptor,
437		    sizeof (uint32_t));
438		offset_tbl[cnt].segnum = cnt;
439		offset_tbl[cnt].offset = segment->offset;
440		offset_tbl[cnt].length = segment->length;
441		offset_tbl[cnt].fixed = segdesc.field.fixed;
442	}
443
444	/* upper boundary of segment area (lower address bytes) */
445	offset_tbl[cnt].segnum = -1;
446	offset_tbl[cnt].offset = sizeof (section_layout_t) +
447	    ((cnt + 1) * sizeof (segment_layout_t));
448
449	offset_tbl[cnt].length = 0;
450	offset_tbl[cnt].fixed  = 1;
451	/* lower boundary of segment area (higher address bytes) */
452
453	offset_tbl[cnt+1].segnum = -1;
454	offset_tbl[cnt+1].offset = secsize;
455	offset_tbl[cnt+1].length = 0;
456	offset_tbl[cnt+1].fixed = 1;
457	return (0);
458}
459
460static int
461hole_discovery(int bytes, int segcnt, int *totsize, seg_info_t *offset_tbl)
462{
463	int cnt = 0;
464
465	*totsize = 0;
466	for (cnt = segcnt + 1; cnt > 0; cnt--) {
467		if (bytes <= offset_tbl[cnt].offset -
468		    (offset_tbl[cnt - 1].offset +
469		    offset_tbl[cnt - 1].length)) {
470			return (offset_tbl[cnt].offset - bytes);
471		}
472
473		*totsize += offset_tbl[cnt].offset -
474		    (offset_tbl[cnt - 1].offset + offset_tbl[cnt - 1].length);
475	}
476	return (0);
477}
478
479
480/*
481 * Description : segment_hdr_present() verify space for new segment header to
482 *              be added.
483 */
484
485static int
486segment_hdr_present(int segoffset, int size, seg_info_t *offset_tbl)
487{
488	if ((segoffset + size) <= offset_tbl[0].offset)
489		return (0);
490	else
491		return (-1);
492}
493
494/*
495 * Description : find_offset() is called from fru_add_segment routine to find
496 *              a valid offset.
497 */
498
499static int
500find_offset(char *seghdr, int segcnt, int secsize, int *sectionoffset,
501    int segsize, int fix, container_hdl_t contfd)
502{
503	int		ret;
504	int		newoffset;
505	int		totsize = 0;
506	seg_info_t	*offset_tbl;
507
508	if (segcnt == 0) {
509		if (!fix) {	/* if not fixed segment */
510			*sectionoffset = secsize - segsize;
511		}
512		return (0);
513	}
514
515	/*
516	 * two extra segment info structure are allocated for start of segment
517	 * and other end of segment. first segment offset is first available
518	 * space and length is 0. second segment offset is is segment length and
519	 * offset is 0. build_offset_tbl() explains how upper boundary and lower
520	 * boudary segment area are initialized in seg_info_t table.
521	 */
522
523	offset_tbl    = malloc((segcnt + 2) * sizeof (seg_info_t));
524	if (offset_tbl == NULL) {
525		return (-1);
526	}
527
528	/* read all the segment header to make offset table */
529	ret = build_offset_tbl(seghdr, segcnt, secsize, offset_tbl);
530	if (ret != 0) {
531		free(offset_tbl);
532		return (-1);
533	}
534
535	/* sort the table */
536	sort_offsettbl(segcnt, offset_tbl);
537
538	/* new segment header offset */
539	newoffset = sizeof (section_layout_t) + segcnt *
540	    sizeof (segment_layout_t);
541
542	/* do? new segment header overlap any existing data */
543	ret = segment_hdr_present(newoffset, sizeof (segment_layout_t),
544	    offset_tbl);
545	if (ret != 0) { /* make room for new segment if possible */
546
547	/* look for hole in order to move segment data */
548		if (offset_tbl[0].fixed == SEGMENT_FIXED) { /* fixed segment */
549			free(offset_tbl);
550			return (-1);
551		}
552
553		newoffset = hole_discovery(offset_tbl[0].length, segcnt,
554		    &totsize, offset_tbl);
555		if (newoffset != 0) { /* found new offset */
556				/* now new offset */
557			offset_tbl[0].offset = newoffset;
558
559			/* move the segment data */
560			move_segment_data(seghdr, newoffset, contfd);
561			/* again sort the offset table */
562			sort_offsettbl(segcnt, offset_tbl);
563		} else {
564			/* pack the existing hole */
565			if (totsize > offset_tbl[0].length) {
566				pack_segment_data(seghdr, segcnt, contfd,
567				    offset_tbl);
568			} else {
569				free(offset_tbl);
570				return (-1);
571			}
572		}
573	}
574
575	totsize = 0;
576	newoffset = hole_discovery(segsize, segcnt, &totsize, offset_tbl);
577
578	if (newoffset == 0) { /* No hole found */
579		if (totsize >= segsize) {
580			pack_segment_data(seghdr, segcnt, contfd, offset_tbl);
581			newoffset = hole_discovery(segsize, segcnt, &totsize,
582			    offset_tbl);
583			if (newoffset != 0) {
584				*sectionoffset = newoffset;
585				free(offset_tbl);
586				return (0);
587			}
588		}
589	} else {
590		*sectionoffset = newoffset;
591		free(offset_tbl);
592		return (0);
593	}
594	free(offset_tbl);
595	return (-1);
596}
597
598static char *
599tokenizer(char *buf, char *separator, char **nextBuf, char *matched)
600{
601	int i = 0;
602	int j = 0;
603
604	for (i = 0; buf[i] != '\0'; i++) {
605		for (j = 0; j < strlen(separator); j++) {
606			if (buf[i] == separator[j]) {
607				buf[i] = '\0';
608				*nextBuf = &(buf[i+1]);
609				*matched = separator[j];
610				return (buf);
611			}
612		}
613	}
614
615	*nextBuf = buf;
616	*matched = '\0';
617	return (NULL);
618}
619
620static int
621get_container_info(const char *def_file, const char *cont_desc_str,
622    container_info_t *cont_info)
623{
624	char	*item;
625	char	*token;
626	char	*field;
627	char	matched;
628	char	buf[1024];
629	int	foundIt = 0;
630	int	ro_tok;
631	int	index;
632	FILE	*file = fopen(def_file, "r");
633
634	if (file == NULL)
635		return (-1);
636
637	cont_info->num_sections = 0;
638
639	while (fgets(buf, sizeof (buf), file) != NULL) {
640		/* ignore all comments */
641		token = tokenizer(buf, "#", &field, &matched);
642		/* find the names */
643		token = tokenizer(buf, ":", &field, &matched);
644		if (token != 0x00) {
645			token = tokenizer(token, "|", &item, &matched);
646			while (token != 0x00) {
647				if (strcmp(token, cont_desc_str) == 0) {
648					foundIt = 1;
649					goto found;
650				}
651				token = tokenizer(item, "|", &item, &matched);
652			}
653			/* check the last remaining item */
654			if ((item != 0x00) &&
655			    (strcmp(item, cont_desc_str) == 0)) {
656				foundIt = 1;
657				goto found;
658			}
659		}
660	}
661
662found :
663	if (foundIt == 1) {
664		token = tokenizer(field, ":", &field, &matched);
665		if (token == 0x00) {
666			(void) fclose(file);
667			return (-1);
668		}
669		cont_info->header_ver = (headerrev_t)atoi(token);
670
671		token = tokenizer(field, ":\n", &field, &matched);
672		while (token != 0x00) {
673			token = tokenizer(token, ",", &item, &matched);
674			if (token == 0x00) {
675				(void) fclose(file);
676				return (-1);
677			}
678			ro_tok = atoi(token);
679			index = cont_info->num_sections;
680			cont_info->section_info[index].encoding = ENC_STANDARD;
681			if (ro_tok == 1) {
682				cont_info->section_info[index].description.
683				    field.read_only = 1;
684			} else if (ro_tok == 0) {
685				cont_info->section_info[index].description.
686				    field.read_only = 0;
687			} else if (ro_tok == 2) {
688				/*
689				 * a value of 2 in the read-only token means
690				 * that the data in this section needs
691				 * re-interpreting
692				 */
693				cont_info->section_info[index].description.
694				    field.read_only = 1;
695			} else {
696				(void) fclose(file);
697				return (-1);
698			}
699
700			token = tokenizer(item, ",", &item, &matched);
701			if (token == 0x00) {
702				(void) fclose(file);
703				return (-1);
704			}
705
706			cont_info->section_info[index].address = atoi(token);
707			if (ro_tok == 2) {
708				/*
709				 * expect an extra parameter to define the
710				 * data interpreter
711				 */
712				token = tokenizer(item, ",", &item, &matched);
713				if (token == 0x00) {
714					(void) fclose(file);
715					return (-1);
716				}
717			}
718			if (item == '\0') {
719				(void) fclose(file);
720				return (-1);
721			}
722			cont_info->section_info[index].size =
723			    ro_tok == 2 ? atoi(token) : atoi(item);
724			if (ro_tok == 2) {
725				if (strcmp(item, "SPD") == 0)
726					cont_info->section_info[index].
727					    encoding = ENC_SPD;
728				else {
729					(void) fclose(file);
730					return (-1);
731				}
732			}
733			(cont_info->num_sections)++;
734
735			token = tokenizer(field, ":\n ", &field, &matched);
736		}
737	}
738	(void) fclose(file);
739	return (0);
740}
741
742/*
743 * Description :fru_open_container() opens the container associated with a fru.
744 *              it's called by data plugin module before creating container
745 *              property.  it calls picltree library routine to get the
746 *              device path and driver binding name for the fru to get the
747 *              corresponding fru name that describe the fru layout.
748 *
749 * Arguments   :picl_hdl_t      fru
750 *              A handle for PICL tree node of class "fru" representing the
751 *              FRU with the container to open.
752 *
753 * Return      :
754 *              On Success, a Positive integer container handle. is returned
755 *              for use in subsequent fru operations;on error, 0 is returned
756 *              and "errno" is set appropriately.
757 */
758
759container_hdl_t
760fru_open_container(picl_nodehdl_t fruhdl)
761{
762	int			retval;
763	int			count;
764	int			device_fd;
765	uchar_t			first_byte;
766	char			*bname;
767	char			devpath[PATH_MAX];
768	char			nmbuf[SYS_NMLN];
769	hash_obj_t		*cont_hash_obj;
770	hash_obj_t		*sec_hash_obj;
771	picl_nodehdl_t		tmphdl;
772	picl_prophdl_t		prophdl;
773	ptree_propinfo_t	propinfo;
774	container_info_t	cont_info;
775
776	/* Get property handle of _seeprom_source under fru node */
777	retval = ptree_get_propval_by_name(fruhdl, PICL_REFPROP_SEEPROM_SRC,
778	    &tmphdl, sizeof (tmphdl));
779	if (retval != PICL_SUCCESS) {
780		return (NULL);
781	}
782
783	/* Get the device path of the fru */
784	retval = ptree_get_propval_by_name(tmphdl, PICL_PROP_DEVICEPATH,
785	    devpath, PATH_MAX);
786	if (retval != PICL_SUCCESS) {
787		return (NULL);
788	}
789
790	retval = ptree_get_prop_by_name(tmphdl, PICL_PROP_BINDING_NAME,
791	    &prophdl);
792	if (retval != PICL_SUCCESS) {
793		return (NULL);
794	}
795
796	retval = ptree_get_propinfo(prophdl, &propinfo);
797	if (retval != PICL_SUCCESS) {
798		return (NULL);
799	}
800
801	bname = alloca(propinfo.piclinfo.size);
802	if (bname == NULL) {
803		return (NULL);
804	}
805
806	/* get the driver binding name */
807	retval = ptree_get_propval(prophdl, bname, propinfo.piclinfo.size);
808	if (retval != PICL_SUCCESS) {
809		return (NULL);
810	}
811
812	cont_hash_obj	= create_container_hash_object();
813	if (cont_hash_obj == NULL) {
814		return (NULL);
815	}
816
817	add_hashobject_to_hashtable(cont_hash_obj);
818
819	(void) strlcpy(cont_hash_obj->u.cont_obj->device_pathname, devpath,
820	    sizeof (devpath));
821
822	/* check for sun or non-sun type fru */
823	if (strcmp(bname, "i2c-at34c02") == 0) {
824		device_fd = open(devpath, O_RDONLY);
825		if (device_fd < 0) {
826			return (NULL);
827		}
828		first_byte = 0x00;
829
830		retval = pread(device_fd, &first_byte, sizeof (first_byte), 0);
831		(void) close(device_fd);
832		switch (first_byte) {
833			case 0x08:
834				(void) strcpy(bname, "i2c-at34cps");
835				break;
836			case 0x80:
837				(void) strcpy(bname, "i2c-at34c02");
838				break;
839			default:
840				(void) strcpy(bname, "i2c-at34cuk");
841				break;
842		}
843	}
844
845	/* if there's a platform-specific conf file, use that */
846	retval = -1;
847	if (sysinfo(SI_PLATFORM, nmbuf, sizeof (nmbuf)) != -1) {
848		(void) snprintf(devpath, PATH_MAX, PICLD_PLAT_PLUGIN_DIRF,
849		    nmbuf);
850		(void) strlcat(devpath, FRU_CONTAINER_CONF, PATH_MAX);
851		retval = access(devpath, R_OK);
852	}
853	if (retval != 0) {
854		/* nothing for the platform, try the base name */
855		(void) snprintf(devpath, PATH_MAX, "%s/%s",
856		    CONTAINER_DIR, FRU_CONTAINER_CONF);
857		retval = access(devpath, R_OK);
858	}
859	/* matches driver binding name to get container information */
860	if (retval == 0) {
861		retval = get_container_info(devpath, bname, &cont_info);
862	}
863	if (retval < 0) {
864		return (NULL);
865	}
866
867	cont_hash_obj->u.cont_obj->num_of_section =  cont_info.num_sections;
868	cont_hash_obj->u.cont_obj->sec_obj_list = NULL;
869
870	for (count = 0; count < cont_info.num_sections; count++) {
871		sec_hash_obj = create_section_hash_object();
872		if (sec_hash_obj == NULL) {
873			return (NULL);
874		}
875
876		add_hashobject_to_hashtable(sec_hash_obj);
877
878		sec_hash_obj->u.sec_obj->section.offset =
879		    cont_info.section_info[count].address;
880
881		sec_hash_obj->u.sec_obj->section.protection =
882		    cont_info.section_info[count].description.field.read_only;
883
884		sec_hash_obj->u.sec_obj->section.length =
885		    cont_info.section_info[count].size;
886
887		sec_hash_obj->u.sec_obj->section.version = cont_info.header_ver;
888		sec_hash_obj->u.sec_obj->encoding =
889		    cont_info.section_info[count].encoding;
890
891		add_to_sec_object_list(cont_hash_obj, sec_hash_obj);
892	}
893	return (cont_hash_obj->obj_hdl);
894}
895
896static int
897verify_header_crc8(headerrev_t head_ver, unsigned char *bytes, int length)
898{
899	int		crc_offset = 0;
900	unsigned char	orig_crc8 = 0;
901	unsigned char	calc_crc8 = 0;
902
903	switch (head_ver) {
904		case SECTION_HDR_VER:
905			crc_offset = 4;
906			break;
907		default:
908			errno = EINVAL;
909			return (0);
910	}
911
912	orig_crc8 = bytes[crc_offset];
913	bytes[crc_offset] = 0x00; /* clear for calc */
914	calc_crc8 = compute_crc8(bytes, length);
915	bytes[crc_offset] = orig_crc8; /* restore */
916	return (orig_crc8 == calc_crc8);
917}
918
919/*
920 * Description	:
921 *		fru_get_num_sections() returns number of sections in a
922 *		container. it calls get_container_index() to get the container
923 *		index number in the container list.
924 *
925 * Arguments	:
926 *		container_hdl_t	: container handle.
927 *
928 * Return	:
929 *		int
930 *		On success, returns number of sections in a container.
931 *
932 */
933
934/* ARGSUSED */
935int
936fru_get_num_sections(container_hdl_t container, door_cred_t *cred)
937{
938	hash_obj_t		*hash_object;
939
940	hash_object	= lookup_handle_object(container, CONTAINER_TYPE);
941	if (hash_object == NULL) {
942		return (-1);
943	}
944
945	return (hash_object->u.cont_obj->num_of_section);
946}
947
948/*
949 * called from fru_get_sections()
950 */
951
952static void
953get_section(int fd, hash_obj_t *sec_hash, section_t *section)
954{
955	int			retval;
956	int			size;
957	int			count;
958	uint16_t		hdrver;
959	hash_obj_t		*seg_hash;
960	unsigned char		*buffer;
961	section_obj_t		*sec_obj;
962	section_layout_t	sec_hdr;
963	segment_layout_t	*seg_hdr;
964	segment_layout_t	*seg_buf;
965
966	sec_obj	= sec_hash->u.sec_obj;
967	if (sec_obj == NULL) {
968		return;
969	}
970
971	/* populate section_t */
972	section->handle = sec_hash->obj_hdl;
973	section->offset = sec_obj->section.offset;
974	section->length = sec_obj->section.length;
975	section->protection = sec_obj->section.protection;
976	section->version = sec_obj->section.version;
977	sec_obj->num_of_segment	= 0;
978
979	switch (sec_obj->encoding) {
980	case ENC_STANDARD:
981		/* read section header layout */
982		retval = pread(fd, &sec_hdr, sizeof (sec_hdr),
983		    sec_obj->section.offset);
984		break;
985
986	case ENC_SPD:
987		retval = get_sp_sec_hdr(&sec_hdr, sizeof (sec_hdr));
988		break;
989
990	default:
991		return;
992	}
993
994	if (retval != sizeof (sec_hdr)) {
995		return;
996	}
997
998	hdrver	= GET_SECTION_HDR_VERSION;
999
1000	if ((sec_hdr.headertag != SECTION_HDR_TAG) &&
1001	    (hdrver != section->version)) {
1002		return;
1003	}
1004
1005	/* size = section layout + total sizeof segment header */
1006	size	= sizeof (sec_hdr) + ((sec_hdr.segmentcount) *
1007	    sizeof (segment_layout_t));
1008
1009	buffer	= alloca(size);
1010	if (buffer == NULL) {
1011		return;
1012	}
1013
1014	/* segment header buffer */
1015	seg_buf = alloca(size - sizeof (sec_hdr));
1016	if (seg_buf == NULL) {
1017		return;
1018	}
1019
1020	switch (sec_obj->encoding) {
1021	case ENC_STANDARD:
1022		/* read segment header */
1023		retval = pread(fd, seg_buf, size - sizeof (sec_hdr),
1024		    sec_obj->section.offset + sizeof (sec_hdr));
1025		break;
1026
1027	case ENC_SPD:
1028		retval =
1029		    get_sp_seg_hdr(seg_buf, size - sizeof (sec_hdr));
1030		break;
1031
1032	default:
1033		return;
1034	}
1035
1036	if (retval != (size - sizeof (sec_hdr))) {
1037		return;
1038	}
1039
1040	/* copy section header layout */
1041	(void) memcpy(buffer, &sec_hdr, sizeof (sec_hdr));
1042
1043	/* copy segment header layout */
1044	(void) memcpy(buffer + sizeof (sec_hdr), seg_buf, size -
1045	    sizeof (sec_hdr));
1046
1047	/* verify crc8 */
1048	retval = verify_header_crc8(hdrver, buffer, size);
1049	if (retval != TRUE) {
1050		return;
1051	}
1052
1053	section->version = hdrver;
1054	sec_obj->section.version = hdrver;
1055
1056	seg_hdr	= (segment_layout_t *)seg_buf;
1057
1058	for (count = 0; count < sec_hdr.segmentcount; count++, seg_hdr++) {
1059		seg_hash = create_segment_hash_object();
1060		if (seg_hash == NULL) {
1061			return;
1062		}
1063
1064		add_hashobject_to_hashtable(seg_hash);
1065
1066		copy_segment_layout(&seg_hash->u.seg_obj->segment, seg_hdr);
1067
1068		add_to_seg_object_list(sec_hash, seg_hash);
1069
1070		sec_obj->num_of_segment++;
1071	}
1072}
1073
1074
1075static int
1076call_devfsadm(void)
1077{
1078	char		*phys_path;
1079	di_node_t	root_node;
1080	di_node_t	prom_node;
1081	di_node_t	f_node;
1082
1083	if ((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
1084		return (-1);
1085	}
1086
1087	f_node = di_drv_first_node(PICL_CLASS_SEEPROM, root_node);
1088	if (f_node != DI_NODE_NIL) {
1089		phys_path = di_devfs_path(f_node);
1090		if ((prom_node = di_init(phys_path, DINFOMINOR)) !=
1091		    DI_NODE_NIL) {
1092			di_fini(prom_node);
1093			di_fini(root_node);
1094			(void) pclose(popen(devfsadm_cmd, "r"));
1095			return (0);
1096		}
1097	}
1098	di_fini(root_node);
1099	return (-1);
1100}
1101
1102/*
1103 * Description	:
1104 *   		fru_get_sections() fills an array of section structures passed
1105 *		as an argument.
1106 *
1107 * Arguments	:
1108 *		container_hdl_t : container handle(device descriptor).
1109 *		section_t	: array of section structure.
1110 *		int		: maximum number of section in a container.
1111 *
1112 * Returns	:
1113 *   		int
1114 *     		On success,the number of section structures written is returned;
1115 *     		on error, -1 is returned and "errno" is set appropriately.
1116 *
1117 */
1118
1119/* ARGSUSED */
1120int
1121fru_get_sections(container_hdl_t container, section_t *section, int maxsec,
1122							door_cred_t *cred)
1123{
1124	int		device_fd;
1125	int		retrys = 1;
1126	int		count;
1127	hash_obj_t	*cont_object;
1128	hash_obj_t	*sec_hash;
1129
1130	cont_object = lookup_handle_object(container, CONTAINER_TYPE);
1131
1132	if (cont_object == NULL) {
1133		return (-1);
1134	}
1135
1136	if (cont_object->u.cont_obj->num_of_section > maxsec) {
1137		return (-1);
1138	}
1139
1140	sec_hash = cont_object->u.cont_obj->sec_obj_list;
1141	if (sec_hash == NULL) {
1142		return (-1);
1143	}
1144
1145	do {
1146		device_fd =
1147		    open(cont_object->u.cont_obj->device_pathname, O_RDONLY);
1148		if (device_fd >= 0) {
1149			break;
1150		}
1151	} while ((retrys-- > 0) && (call_devfsadm() == 0));
1152
1153	if (device_fd < 0) {
1154		return (-1);
1155	}
1156
1157	for (count = 0; count < cont_object->u.cont_obj->num_of_section;
1158	    count++, section++) {
1159		section->version = -1;
1160		/* populate section_t */
1161		get_section(device_fd, sec_hash, section);
1162		sec_hash = sec_hash->u.sec_obj->next;
1163	}
1164
1165	(void) close(device_fd);
1166	return (count);
1167}
1168
1169/*
1170 * Description	:
1171 * 		fru_get_num_segments() returns the current number of segments
1172 *		in a section.
1173 *
1174 * Arguments	:
1175 *		section_hdl_t : section header holding section information.
1176 *
1177 * Return	:
1178 * 		int
1179 *     		On success, the number of segments in the argument section is
1180 *     		returned; on error -1 is returned.
1181 */
1182
1183/* ARGSUSED */
1184int
1185fru_get_num_segments(section_hdl_t section, door_cred_t *cred)
1186{
1187	hash_obj_t	*sec_object;
1188	section_obj_t	*sec_obj;
1189
1190	sec_object	= lookup_handle_object(section, SECTION_TYPE);
1191	if (sec_object == NULL) {
1192		return (-1);
1193	}
1194
1195	sec_obj	= sec_object->u.sec_obj;
1196	if (sec_obj == NULL) {
1197		return (-1);
1198	}
1199
1200	return (sec_obj->num_of_segment);
1201}
1202
1203/*
1204 * Description	:
1205 *		fru_get_segments() fills an array of structures representing the
1206 *		segments in a section.
1207 *
1208 * Arguments	:
1209 *		section_hdl_t : holds section number.
1210 *		segment_t : on success will hold segment information.
1211 *		int	: maximum number of segment.
1212 *
1213 * Return	:
1214 *		int
1215 *		On success, the number of segment structures written is
1216 *		returned; on errno -1 is returned.
1217 */
1218
1219/* ARGSUSED */
1220int
1221fru_get_segments(section_hdl_t section, segment_t *segment, int maxseg,
1222    door_cred_t *cred)
1223{
1224	int		count;
1225	hash_obj_t	*sec_object;
1226	hash_obj_t	*seg_object;
1227	section_obj_t	*sec_obj;
1228
1229	sec_object = lookup_handle_object(section, SECTION_TYPE);
1230	if (sec_object == NULL) {
1231		return (-1);
1232	}
1233
1234	sec_obj	= sec_object->u.sec_obj;
1235	if (sec_obj == NULL) {
1236		return (-1);
1237	}
1238
1239	if (sec_obj->num_of_segment > maxseg) {
1240		return (-1);
1241	}
1242
1243	seg_object	= sec_object->u.sec_obj->seg_obj_list;
1244	if (seg_object == NULL) {
1245		return (-1);
1246	}
1247
1248	for (count = 0; count < sec_obj->num_of_segment; count++) {
1249
1250		/* populate segment_t */
1251		segment->handle = seg_object->obj_hdl;
1252		(void) memcpy(segment->name,
1253		    seg_object->u.seg_obj->segment.name, SEG_NAME_LEN);
1254		segment->descriptor = seg_object->u.seg_obj->segment.descriptor;
1255
1256		segment->offset	= seg_object->u.seg_obj->segment.offset;
1257		segment->length	= seg_object->u.seg_obj->segment.length;
1258		seg_object = seg_object->u.seg_obj->next;
1259		segment++;
1260	}
1261	return (0);
1262}
1263
1264/*
1265 * Description	:
1266 *		fru_add_segment() adds a segment to a section.
1267 *
1268 * Arguments	:
1269 *		section_hdl_t section
1270 *		A handle for the section in which to add the segment.
1271 *
1272 *		segment_t *segment
1273 *		On entry, the "handle" component of "segment" is ignored and the
1274 *		remaining components specify the parameters of the segment to be
1275 *		added.  On return, the "handle" component is set to the handle
1276 *		for the added segment. The segment offset is mandatory for FIXED
1277 *		segments; otherwise, the offset is advisory.
1278 *
1279 * Return	:
1280 *		int
1281 *		On success, 0 is returned; on error -1 is returned.
1282 *
1283 */
1284
1285int
1286fru_add_segment(section_hdl_t section, segment_t *segment,
1287				section_hdl_t *newsection, door_cred_t *cred)
1288{
1289	int		fd;
1290	int		retval;
1291	int		offset;
1292	int		sec_size;
1293	int		seg_cnt;
1294	int		bufsize;
1295	int		new_seg_offset;
1296	int		new_seg_length;
1297	int		fixed_segment;
1298	char		trailer[]	= { 0x0c, 0x00, 0x00, 0x00, 0x00 };
1299	hash_obj_t	*cont_hash;
1300	hash_obj_t	*sec_hash;
1301	hash_obj_t	*seg_hash;
1302	fru_segdesc_t	*new_seg_desc;
1303	unsigned char 	*crcbuf;
1304	section_layout_t sec_layout;
1305	segment_layout_t *seg_layout;
1306	segment_layout_t *segment_buf;
1307
1308	/* check the effective uid of the client */
1309	if (cred->dc_euid != 0) {
1310		errno = EPERM;
1311		return (-1);	/* not a root */
1312	}
1313
1314	/* section hash */
1315	sec_hash = lookup_handle_object(section, SECTION_TYPE);
1316	if (sec_hash == NULL) {
1317		return (-1);
1318	}
1319
1320	/* check for read-only section */
1321	if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
1322		errno = EPERM;
1323		return (-1);
1324	}
1325
1326	/* look for duplicate segment */
1327	seg_hash = sec_hash->u.sec_obj->seg_obj_list;
1328	while (seg_hash != NULL) {
1329		if (strncmp(segment->name, seg_hash->u.seg_obj->segment.name,
1330		    SEG_NAME_LEN) == 0) {
1331			errno = EEXIST;
1332			return (-1); /* can't add duplicate segment */
1333		}
1334		seg_hash = seg_hash->u.seg_obj->next;
1335	}
1336
1337	/* get the container hash */
1338	cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
1339	    CONTAINER_TYPE);
1340	if (cont_hash == NULL) {
1341		return (-1);
1342	}
1343
1344	/* open the container */
1345	fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
1346	if (fd < 0) {
1347		return (-1);
1348	}
1349
1350	/* section start here */
1351	offset	= sec_hash->u.sec_obj->section.offset;
1352
1353	/* read section header layout */
1354	retval = pread(fd, &sec_layout, sizeof (sec_layout), offset);
1355	if (retval != sizeof (sec_layout)) {
1356		(void) close(fd);
1357		return (-1);
1358	}
1359
1360	/* check for valid section header */
1361	if (sec_layout.headertag != SECTION_HDR_TAG) {
1362		/* write a new one */
1363		sec_layout.headertag		= SECTION_HDR_TAG;
1364		sec_layout.headerversion[0]	= SECTION_HDR_VER_BIT0;
1365		sec_layout.headerversion[1]	= SECTION_HDR_VER_BIT1;
1366		sec_layout.headerlength		= sizeof (sec_layout);
1367		sec_layout.segmentcount		= 0;
1368	}
1369
1370	/* section size */
1371	sec_size	= sec_hash->u.sec_obj->section.length;
1372
1373	/* number of segment in the section */
1374	seg_cnt	= sec_layout.segmentcount;
1375
1376	/* total sizeof segment + new segment */
1377	bufsize	=	sizeof (segment_layout_t) * (seg_cnt + 1);
1378	segment_buf = alloca(bufsize);
1379	if (segment_buf == NULL) {
1380		return (-1);
1381	}
1382
1383	/* read entire segment header */
1384	retval = pread(fd, segment_buf,  (bufsize - sizeof (segment_layout_t)),
1385	    offset + sizeof (section_layout_t));
1386	if (retval != (bufsize - sizeof (segment_layout_t))) {
1387		(void) close(fd);
1388		return (-1);
1389	}
1390
1391	new_seg_offset	= segment->offset; /* new segment offset */
1392	new_seg_length	= segment->length; /* new segment length */
1393
1394	new_seg_desc	= (fru_segdesc_t *)&segment->descriptor;
1395
1396	fixed_segment	= new_seg_desc->field.fixed;
1397
1398	/* get new offset for new segment to be addedd */
1399	retval = find_offset((char *)segment_buf, seg_cnt, sec_size,
1400	    &new_seg_offset, new_seg_length, fixed_segment, fd);
1401
1402	if (retval != 0)	{
1403		(void) close(fd);
1404		errno = EAGAIN;
1405		return (-1);
1406	}
1407
1408	/* copy new segment data in segment layout */
1409	seg_layout	= (segment_layout_t *)(segment_buf + seg_cnt);
1410	(void) memcpy(&seg_layout->name, segment->name, SEG_NAME_LEN);
1411	(void) memcpy(seg_layout->descriptor, &segment->descriptor,
1412	    sizeof (uint32_t));
1413	seg_layout->length	= segment->length;
1414	seg_layout->offset	= new_seg_offset; /* new segment offset */
1415
1416	sec_layout.segmentcount += 1;
1417
1418	crcbuf	= alloca(sizeof (section_layout_t) + bufsize);
1419	if (crcbuf == NULL) {
1420		(void) close(fd);
1421		return (-1);
1422	}
1423
1424	sec_layout.headercrc8 = 0;
1425	sec_layout.headerlength += sizeof (segment_layout_t);
1426
1427	(void) memcpy(crcbuf, (char *)&sec_layout, sizeof (section_layout_t));
1428	(void) memcpy(crcbuf + sizeof (section_layout_t), segment_buf, bufsize);
1429
1430	sec_layout.headercrc8 = compute_crc8(crcbuf, bufsize +
1431	    sizeof (section_layout_t));
1432
1433	/* write section header */
1434	retval = pwrite(fd, &sec_layout, sizeof (section_layout_t), offset);
1435	if (retval != sizeof (section_layout_t)) {
1436		(void) close(fd);
1437		return (-1);
1438	}
1439
1440	/* write segment header */
1441	retval = pwrite(fd, segment_buf, bufsize, offset +
1442	    sizeof (section_layout_t));
1443	if (retval != bufsize) {
1444		(void) close(fd);
1445		return (-1);
1446	}
1447
1448	/* write segment trailer */
1449	retval = pwrite(fd, &trailer, sizeof (trailer), new_seg_offset);
1450	if (retval != sizeof (trailer)) {
1451		(void) close(fd);
1452		return (-1);
1453	}
1454
1455	(void) close(fd);
1456
1457	/* create new segment hash object */
1458	seg_hash	= create_segment_hash_object();
1459	if (seg_hash == NULL) {
1460		return (-1);
1461	}
1462
1463	add_hashobject_to_hashtable(seg_hash);
1464
1465	copy_segment_layout(&seg_hash->u.seg_obj->segment, seg_layout);
1466
1467	add_to_seg_object_list(sec_hash, seg_hash);
1468
1469	sec_hash->u.sec_obj->num_of_segment += 1;
1470	seg_hash->u.seg_obj->trailer_offset = new_seg_offset;
1471	*newsection	= section; /* return the new section handle */
1472	return (0);
1473}
1474
1475static void
1476free_pkt_object_list(hash_obj_t	*hash_obj)
1477{
1478	hash_obj_t	*next_obj;
1479	hash_obj_t	*free_obj;
1480
1481	next_obj = hash_obj->u.seg_obj->pkt_obj_list;
1482	while (next_obj != NULL) {
1483		free_obj = next_obj;
1484		next_obj = next_obj->u.pkt_obj->next;
1485		/* if prev is NULL it's the first object in the list */
1486		if (free_obj->prev == NULL) {
1487			hash_table[(free_obj->obj_hdl % TABLE_SIZE)] =
1488			    free_obj->next;
1489			if (free_obj->next != NULL) {
1490				free_obj->next->prev = free_obj->prev;
1491			}
1492		} else {
1493			free_obj->prev->next = free_obj->next;
1494			if (free_obj->next != NULL) {
1495				free_obj->next->prev = free_obj->prev;
1496			}
1497		}
1498
1499		free(free_obj->u.pkt_obj->payload);
1500		free(free_obj->u.pkt_obj);
1501		free(free_obj);
1502	}
1503
1504	hash_obj->u.seg_obj->pkt_obj_list = NULL;
1505}
1506
1507static void
1508free_segment_hash(handle_t	handle, hash_obj_t	*sec_hash)
1509{
1510	hash_obj_t	*seg_hash;
1511	hash_obj_t	*next_hash;
1512
1513	seg_hash	= sec_hash->u.sec_obj->seg_obj_list;
1514	if (seg_hash == NULL) {
1515		return;
1516	}
1517
1518	if (seg_hash->obj_hdl == handle) {
1519		sec_hash->u.sec_obj->seg_obj_list = seg_hash->u.seg_obj->next;
1520	} else {
1521		while (seg_hash->obj_hdl != handle) {
1522			next_hash	= seg_hash;
1523			seg_hash = seg_hash->u.seg_obj->next;
1524			if (seg_hash == NULL) {
1525				return;
1526			}
1527		}
1528		next_hash->u.seg_obj->next = seg_hash->u.seg_obj->next;
1529	}
1530
1531	if (seg_hash->prev == NULL) {
1532		hash_table[(seg_hash->obj_hdl % TABLE_SIZE)] = seg_hash->next;
1533		if (seg_hash->next != NULL) {
1534			seg_hash->next->prev = NULL;
1535		}
1536	} else {
1537		seg_hash->prev->next = seg_hash->next;
1538		if (seg_hash->next != NULL) {
1539			seg_hash->next->prev = seg_hash->prev;
1540		}
1541	}
1542
1543	free_pkt_object_list(seg_hash);
1544	free(seg_hash->u.seg_obj);
1545	free(seg_hash);
1546}
1547
1548/*
1549 * Description	:
1550 *		fru_delete_segment() deletes a segment from a section; the
1551 *		associated container data is not altered.
1552 *
1553 * Arguments	: segment_hdl_t	segment handle.
1554 *		  section_hdl_t	new section handle.
1555 *
1556 * Return	:
1557 *		int
1558 *		On success, 0 returned; On error -1 is returned.
1559 */
1560
1561int
1562fru_delete_segment(segment_hdl_t segment, section_hdl_t *newsection,
1563							door_cred_t *cred)
1564{
1565	int			num_of_seg;
1566	int			bufsize;
1567	int			count;
1568	int			retval;
1569	int			fd;
1570	int			segnum;
1571	hash_obj_t		*seg_hash;
1572	hash_obj_t		*sec_hash;
1573	hash_obj_t		*cont_hash;
1574	hash_obj_t		*tmp_hash;
1575	unsigned char		*buffer;
1576	fru_segdesc_t		*desc;
1577	segment_layout_t	*seg_buf;
1578	section_layout_t	*sec_layout;
1579	segment_layout_t	*seg_layout;
1580	segment_layout_t	*next_layout;
1581
1582	/* check the effective uid of the client */
1583	if (cred->dc_euid != 0) {
1584		errno = EPERM;
1585		return (-1);	/* not a root */
1586	}
1587
1588	seg_hash = lookup_handle_object(segment, SEGMENT_TYPE);
1589	if (seg_hash == NULL) {
1590		return (-1);
1591	}
1592
1593	desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
1594	if (!(desc->field.field_perm & SEGMENT_DELETE)) {
1595		errno = EPERM;
1596		return (-1); /* can't delete this segment */
1597	}
1598
1599	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
1600	    SECTION_TYPE);
1601	if (sec_hash == NULL) {
1602		return (-1);
1603	}
1604
1605	if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
1606		errno = EPERM;
1607		return (-1);
1608	}
1609
1610	num_of_seg	= sec_hash->u.sec_obj->num_of_segment;
1611
1612	bufsize	= (sizeof (segment_layout_t) * num_of_seg);
1613
1614	seg_buf	= alloca(bufsize);
1615	if (seg_buf == NULL) {
1616		return (-1);
1617	}
1618
1619	segnum	= 0;
1620	for (tmp_hash = sec_hash->u.sec_obj->seg_obj_list; tmp_hash != NULL;
1621	    tmp_hash = tmp_hash->u.seg_obj->next) {
1622		if (tmp_hash->obj_hdl == segment) {
1623			break;
1624		}
1625		segnum++;
1626	}
1627
1628	cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
1629	    CONTAINER_TYPE);
1630	if (cont_hash == NULL) {
1631		return (-1);
1632	}
1633
1634	fd  = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
1635	if (fd < 0) {
1636		return (-1);
1637	}
1638
1639	sec_layout	= alloca(sizeof (section_layout_t));
1640	if (sec_layout == NULL) {
1641		(void) close(fd);
1642		return (-1);
1643	}
1644
1645	/* read section layout header */
1646	retval = pread(fd, sec_layout, sizeof (section_layout_t),
1647	    sec_hash->u.sec_obj->section.offset);
1648	if (retval != sizeof (section_layout_t)) {
1649		(void) close(fd);
1650		return (-1);
1651	}
1652
1653	/* read segment header layout */
1654	retval = pread(fd, seg_buf, bufsize,
1655	    sec_hash->u.sec_obj->section.offset + sizeof (section_layout_t));
1656	if (retval != bufsize) {
1657		(void) close(fd);
1658		return (-1);
1659	}
1660
1661	seg_layout = (segment_layout_t *)(seg_buf + segnum);
1662	next_layout	= seg_layout;
1663	for (count = segnum;
1664	    count < sec_hash->u.sec_obj->num_of_segment - 1; count++) {
1665		next_layout++;
1666		(void) memcpy(seg_layout, next_layout,
1667		    sizeof (segment_layout_t));
1668		seg_layout++;
1669	}
1670
1671	(void) memset(seg_layout, '\0', sizeof (segment_layout_t));
1672
1673	sec_layout->headercrc8 = 0;
1674
1675	sec_layout->headerlength -= sizeof (segment_layout_t);
1676	sec_layout->segmentcount -= 1;
1677
1678	buffer = alloca(sec_layout->headerlength);
1679	if (buffer == NULL) {
1680		(void) close(fd);
1681		return (-1);
1682	}
1683
1684	(void) memcpy(buffer, sec_layout, sizeof (section_layout_t));
1685	(void) memcpy(buffer + sizeof (section_layout_t), seg_buf, bufsize -
1686	    sizeof (segment_layout_t));
1687	sec_layout->headercrc8 = compute_crc8(buffer, sec_layout->headerlength);
1688
1689	/* write section header with update crc8 and header length */
1690	retval = pwrite(fd, sec_layout, sizeof (section_layout_t),
1691	    sec_hash->u.sec_obj->section.offset);
1692	if (retval != sizeof (section_layout_t)) {
1693		(void) close(fd);
1694		return (-1);
1695	}
1696
1697	/* write the update segment header */
1698	retval = pwrite(fd, seg_buf, bufsize,
1699	    sec_hash->u.sec_obj->section.offset + sizeof (section_layout_t));
1700	(void) close(fd);
1701	if (retval != bufsize) {
1702		return (-1);
1703	}
1704
1705	free_segment_hash(segment, sec_hash);
1706
1707	*newsection	= sec_hash->obj_hdl;
1708	sec_hash->u.sec_obj->num_of_segment = sec_layout->segmentcount;
1709
1710	return (0);
1711}
1712
1713/*
1714 * Description	:
1715 * 		fru_read_segment() reads the raw contents of a segment.
1716 *
1717 * Arguments	: segment_hdl_t : segment handle.
1718 *		 void *	: buffer containing segment data when function returns.
1719 *		size_t :number of bytes.
1720 *
1721 * Return	:
1722 * 		int
1723 *		On success, the number of bytes read is returned;
1724 *
1725 * Notes	:
1726 *		Segments containing packets can be read in structured fashion
1727 *		using the fru_get_packets() and fru_get_payload() primitives;the
1728 *		entire byte range of a segment can be read using
1729 *		fru_read_segment().
1730 */
1731
1732/* ARGSUSED */
1733ssize_t
1734fru_read_segment(segment_hdl_t segment, void *buffer, size_t nbytes,
1735    door_cred_t *cred)
1736{
1737	int		fd;
1738	int		retval;
1739	hash_obj_t	*seg_hash;
1740	hash_obj_t	*sec_hash;
1741	hash_obj_t	*cont_hash;
1742
1743	/* segment hash object */
1744	seg_hash = lookup_handle_object(segment, SEGMENT_TYPE);
1745	if (seg_hash == NULL) {
1746		return (-1);
1747	}
1748
1749	/* section hash object */
1750	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
1751	    SECTION_TYPE);
1752	if (sec_hash == NULL) {
1753		return (-1);
1754	}
1755
1756	/* container hash object */
1757	cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
1758	    CONTAINER_TYPE);
1759	if (cont_hash == NULL) {
1760		return (-1);
1761	}
1762
1763	if (seg_hash->u.seg_obj->segment.length < nbytes) {
1764		return (-1);
1765	}
1766
1767	fd = open(cont_hash->u.cont_obj->device_pathname, O_RDONLY);
1768	if (fd < 0) {
1769		return (-1);
1770	}
1771
1772	switch (sec_hash->u.sec_obj->encoding) {
1773	case ENC_STANDARD:
1774		retval = pread(fd, buffer, nbytes,
1775		    seg_hash->u.seg_obj->segment.offset);
1776		(void) close(fd);
1777		if (retval != nbytes) {
1778			return (-1);
1779		}
1780		break;
1781
1782	case ENC_SPD: {
1783		char	*spd_buf;
1784		uchar_t	*ptr;
1785		size_t	len;
1786
1787		spd_buf = alloca(sec_hash->u.sec_obj->section.length);
1788		if (spd_buf == NULL)
1789			retval = -1;
1790		else {
1791			retval = get_spd_data(fd, spd_buf,
1792			    sec_hash->u.sec_obj->section.length,
1793			    seg_hash->u.seg_obj->segment.offset);
1794		}
1795		(void) close(fd);
1796		if (retval != 0) {
1797			return (-1);
1798		}
1799		retval = cvrt_dim_data(spd_buf,
1800		    sec_hash->u.sec_obj->section.length, &ptr, &len);
1801		if (retval != 0) {
1802			return (-1);
1803		}
1804		if (nbytes > len)
1805			nbytes = len;
1806		(void) memcpy(buffer, ptr, nbytes);
1807		free(ptr);
1808		break;
1809	}
1810
1811	default:
1812		return (-1);
1813	}
1814
1815	return (nbytes);
1816}
1817
1818/*
1819 * Description	:
1820 *		fru_write_segment() writes a raw segment.
1821 *
1822 * Arguments	: segment_hdl_t :segment handle.
1823 *		 const void * : data buffer.
1824 *		 size_t	: number of bytes.
1825 *		 segment_hdl_t : new segment handle.
1826 *
1827 * Returns	:
1828 *		int
1829 *		On success, the number of bytes written is returned
1830 *
1831 */
1832/*ARGSUSED*/
1833int
1834fru_write_segment(segment_hdl_t segment, const void *data, size_t nbytes,
1835    segment_hdl_t *newsegment, door_cred_t *cred)
1836{
1837	return (ENOTSUP);
1838}
1839
1840
1841static int
1842get_packet(int device_fd, void *buffer, int size, int offset)
1843{
1844	int	retval;
1845
1846	retval = pread(device_fd, (char *)buffer, size, offset);
1847	if (retval != -1) {
1848		return (0);
1849	}
1850	return (-1);
1851}
1852
1853static uint32_t
1854get_checksum_crc(hash_obj_t	*seg_hash, int data_size)
1855{
1856	int		protection;
1857	int		offset = 0;
1858	uint32_t	crc;
1859	hash_obj_t	*sec_hash;
1860	hash_obj_t	*pkt_hash;
1861	unsigned char	*buffer;
1862
1863	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
1864	    SECTION_TYPE);
1865	if (sec_hash == NULL) {
1866		return ((uint32_t)-1);
1867	}
1868
1869	buffer = alloca(data_size);
1870	if (buffer == NULL) {
1871		return ((uint32_t)-1);
1872	}
1873
1874	/* traverse the packet object list for all the tags and payload */
1875	for (pkt_hash = seg_hash->u.seg_obj->pkt_obj_list;
1876	    pkt_hash != NULL; pkt_hash = pkt_hash->u.pkt_obj->next) {
1877		(void) memcpy(buffer + offset, &pkt_hash->u.pkt_obj->tag,
1878		    pkt_hash->u.pkt_obj->tag_size);
1879		offset += pkt_hash->u.pkt_obj->tag_size;
1880		(void) memcpy(buffer + offset, pkt_hash->u.pkt_obj->payload,
1881		    pkt_hash->u.pkt_obj->paylen);
1882		offset += pkt_hash->u.pkt_obj->paylen;
1883	}
1884
1885	protection	= sec_hash->u.sec_obj->section.protection;
1886
1887	if (protection == READ_ONLY_SECTION) { /* read-only section */
1888		crc = compute_crc32(buffer, data_size);
1889	} else {		/* read/write section */
1890		crc = compute_checksum32(buffer, data_size);
1891	}
1892	return (crc);	/* computed crc */
1893}
1894
1895static int
1896get_dev_or_buffered_packets(hash_obj_t *seg_hash, int device_fd, int offset,
1897    int length, const char *buf)
1898{
1899	int		tag_size;
1900	int		paylen;
1901	int		retval;
1902	int		seg_limit = 0;
1903	int		pktcnt	= 0;
1904	char		*data;
1905	uint32_t	crc;
1906	uint32_t	origcrc;
1907	fru_tag_t	tag;
1908	hash_obj_t	*pkt_hash_obj;
1909	fru_segdesc_t	*segdesc;
1910	fru_tagtype_t	tagtype;
1911
1912	if (buf == NULL) {
1913		retval = get_packet(device_fd, &tag, sizeof (fru_tag_t),
1914		    offset);
1915		if (retval == -1) {
1916			return (-1);
1917		}
1918	} else if (length - offset < sizeof (fru_tag_t)) {
1919		return (-1);
1920	} else {
1921		(void) memcpy(&tag, buf + offset, sizeof (fru_tag_t));
1922	}
1923
1924	seg_hash->u.seg_obj->trailer_offset = offset;
1925
1926	data	= (char *)&tag;
1927	while (data[0] != SEG_TRAILER_TAG) {
1928		tagtype	= get_tag_type(&tag); /* verify tag type */
1929		if (tagtype == -1) {
1930			return (-1);
1931		}
1932
1933		tag_size = get_tag_size(tagtype);
1934		if (tag_size == -1) {
1935			return (-1);
1936		}
1937
1938		seg_limit += tag_size;
1939		if (seg_limit > length) {
1940			return (-1);
1941		}
1942
1943		paylen = get_payload_length((void *)&tag);
1944		if (paylen == -1) {
1945			return (-1);
1946		}
1947
1948		seg_limit += paylen;
1949		if (seg_limit > length) {
1950			return (-1);
1951		}
1952
1953		pkt_hash_obj = create_packet_hash_object();
1954		if (pkt_hash_obj == NULL) {
1955			return (-1);
1956		}
1957
1958		pkt_hash_obj->u.pkt_obj->payload = malloc(paylen);
1959		if (pkt_hash_obj->u.pkt_obj->payload == NULL) {
1960			free(pkt_hash_obj);
1961			return (-1);
1962		}
1963
1964		offset += tag_size;
1965		if (buf == NULL) {
1966			retval = pread(device_fd,
1967			    pkt_hash_obj->u.pkt_obj->payload, paylen, offset);
1968		} else if (paylen + offset > length) {
1969			retval = 0;
1970		} else {
1971			(void) memcpy(pkt_hash_obj->u.pkt_obj->payload,
1972			    buf + offset, paylen);
1973			retval = paylen;
1974		}
1975		if (retval != paylen) {
1976			free(pkt_hash_obj->u.pkt_obj->payload);
1977			free(pkt_hash_obj);
1978			return (-1);
1979		}
1980
1981		/* don't change this */
1982		pkt_hash_obj->u.pkt_obj->tag.raw_data = 0;
1983		(void) memcpy(&pkt_hash_obj->u.pkt_obj->tag, &tag, tag_size);
1984		pkt_hash_obj->u.pkt_obj->paylen = paylen;
1985		pkt_hash_obj->u.pkt_obj->tag_size = tag_size;
1986		pkt_hash_obj->u.pkt_obj->payload_offset = offset;
1987
1988		offset += paylen;
1989
1990		add_hashobject_to_hashtable(pkt_hash_obj);
1991		add_to_pkt_object_list(seg_hash, pkt_hash_obj);
1992
1993		pktcnt++;
1994
1995		if (buf == NULL) {
1996			retval = get_packet(device_fd, &tag, sizeof (fru_tag_t),
1997			    offset);
1998			if (retval == -1) {
1999				return (-1);
2000			}
2001		} else if (length - offset < sizeof (fru_tag_t)) {
2002			if (length - offset > 0) {
2003				/*
2004				 * not enough data for a full fru_tag_t
2005				 * just return what there is
2006				 */
2007				(void) memset(&tag, 0, sizeof (fru_tag_t));
2008				(void) memcpy(&tag, buf + offset,
2009				    length - offset);
2010			}
2011		} else {
2012			(void) memcpy(&tag, buf + offset, sizeof (fru_tag_t));
2013		}
2014
2015		data	= (char *)&tag;
2016	}
2017
2018	segdesc	= (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
2019
2020	seg_hash->u.seg_obj->trailer_offset = offset;
2021
2022	if (!segdesc->field.ignore_checksum)  {
2023		crc = get_checksum_crc(seg_hash, seg_limit);
2024		offset	= seg_hash->u.seg_obj->segment.offset;
2025
2026		if (buf == NULL) {
2027			retval = pread(device_fd, &origcrc, sizeof (origcrc),
2028			    offset + seg_limit + 1);
2029			if (retval != sizeof (origcrc)) {
2030				return (-1);
2031			}
2032		} else if (length - offset < sizeof (origcrc)) {
2033			return (-1);
2034		} else {
2035			(void) memcpy(&origcrc, buf + seg_limit + 1,
2036			    sizeof (origcrc));
2037		}
2038
2039		if (origcrc != crc) {
2040			seg_hash->u.seg_obj->trailer_offset = offset;
2041		}
2042	}
2043
2044	return (pktcnt);
2045}
2046
2047static int
2048get_packets(hash_obj_t *seg_hash, int device_fd, int offset, int length)
2049{
2050	return (get_dev_or_buffered_packets(seg_hash, device_fd, offset,
2051	    length, NULL));
2052}
2053
2054static int
2055get_buffered_packets(hash_obj_t *seg_hash, const char *seg_buf, size_t seg_len)
2056{
2057	return (get_dev_or_buffered_packets(seg_hash, -1, 0, seg_len, seg_buf));
2058}
2059
2060/*
2061 * Description	:
2062 *		fru_get_num_packets() returns the current number of packets
2063 *		in a segment.
2064 *
2065 * Arguments	: segment_hdl_t : segment handle.
2066 *
2067 * Return	:
2068 *		int
2069 *		On success, the number of packets is returned;
2070 *		-1 on failure.
2071 */
2072int
2073fru_get_num_packets(segment_hdl_t segment, door_cred_t *cred)
2074{
2075	int		device_fd;
2076	int		pktcnt;
2077	int		length;
2078	uint16_t	offset;
2079	hash_obj_t	*cont_hash_obj;
2080	hash_obj_t	*sec_hash;
2081	hash_obj_t	*seg_hash;
2082	fru_segdesc_t	*segdesc;
2083	segment_obj_t	*segment_object;
2084
2085	seg_hash	= lookup_handle_object(segment, SEGMENT_TYPE);
2086	if (seg_hash == NULL) {
2087		return (-1);
2088	}
2089
2090	segment_object	= seg_hash->u.seg_obj;
2091	if (segment_object == NULL) {
2092		return (-1);
2093	}
2094
2095	segdesc = (fru_segdesc_t *)&segment_object->segment.descriptor;
2096	if (segdesc->field.opaque) {
2097		return (0);
2098	}
2099
2100	if (seg_hash->u.seg_obj->pkt_obj_list != NULL) {
2101		return (segment_object->num_of_packets);
2102	}
2103
2104	offset = segment_object->segment.offset;
2105	length = segment_object->segment.length;
2106
2107	/* section hash object */
2108	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
2109	    SECTION_TYPE);
2110	if (sec_hash == NULL) {
2111		return (-1);
2112	}
2113
2114	segment_object->num_of_packets = 0;
2115
2116	switch (sec_hash->u.sec_obj->encoding) {
2117	case ENC_STANDARD:
2118		cont_hash_obj = get_container_hash_object(SEGMENT_TYPE,
2119		    segment_object->section_hdl);
2120		if (cont_hash_obj == NULL) {
2121			return (-1);
2122		}
2123		device_fd = open(cont_hash_obj->u.cont_obj->device_pathname,
2124		    O_RDWR);
2125		if (device_fd < 0) {
2126			return (-1);
2127		}
2128
2129		pktcnt = get_packets(seg_hash, device_fd, offset, length);
2130		(void) close(device_fd);
2131		break;
2132
2133	case ENC_SPD: {
2134		ssize_t		spd_seg_len;
2135		size_t		nbytes;
2136		char		*seg_buf;
2137
2138		nbytes = segment_object->segment.length;
2139		seg_buf = alloca(nbytes);
2140		if (seg_buf == NULL)
2141			return (-1);
2142		spd_seg_len =
2143		    fru_read_segment(segment, seg_buf, nbytes, cred);
2144		if (spd_seg_len < 0)
2145			return (-1);
2146		pktcnt = get_buffered_packets(seg_hash, seg_buf,
2147		    spd_seg_len);
2148		break;
2149	}
2150
2151	default:
2152		return (-1);
2153	}
2154
2155	if (pktcnt == -1) {
2156		free_pkt_object_list(seg_hash);
2157		seg_hash->u.seg_obj->pkt_obj_list = NULL;
2158	}
2159
2160	segment_object->num_of_packets = pktcnt;
2161
2162	return (segment_object->num_of_packets);
2163}
2164
2165
2166/*
2167 * Description	:
2168 *		fru_get_packets() fills an array of structures representing the
2169 *		packets in a segment.
2170 *
2171 * Arguments	: segment_hdl_t : segment handle.
2172 *		packet_t	: packet buffer.
2173 *		int	: maximum number of packets.
2174 *
2175 * Return	:
2176 *		int
2177 *		On success, the number of packet structures written is returned;
2178 *		On failure -1 is returned;
2179 *
2180 */
2181
2182/* ARGSUSED */
2183int
2184fru_get_packets(segment_hdl_t segment, packet_t *packet, int maxpackets,
2185    door_cred_t *cred)
2186{
2187	int		count;
2188	hash_obj_t	*seg_hash_obj;
2189	hash_obj_t	*pkt_hash_obj;
2190
2191	/* segment hash object */
2192	seg_hash_obj	= lookup_handle_object(segment, SEGMENT_TYPE);
2193	if (seg_hash_obj == NULL) {
2194		return (-1);
2195	}
2196
2197	if (seg_hash_obj->u.seg_obj->num_of_packets != maxpackets) {
2198		return (-1);
2199	}
2200
2201	pkt_hash_obj	= seg_hash_obj->u.seg_obj->pkt_obj_list;
2202	if (pkt_hash_obj == NULL) {
2203		return (-1);
2204	}
2205
2206	for (count = 0; count < maxpackets; count++, packet++) {
2207		packet->handle	= pkt_hash_obj->obj_hdl;
2208		packet->tag = 0;
2209		(void) memcpy(&packet->tag, &pkt_hash_obj->u.pkt_obj->tag,
2210		    pkt_hash_obj->u.pkt_obj->tag_size);
2211		pkt_hash_obj = pkt_hash_obj->u.pkt_obj->next;
2212	}
2213
2214	return (0);
2215}
2216
2217/*
2218 * Description	:
2219 *		fru_get_payload() copies the contents of a packet's payload.
2220 *
2221 * Arguments	: packet_hdl_t : packet handle.
2222 *		void *	: payload buffer.
2223 *		size_t	: sizeof the buffer.
2224 *
2225 * Return	:
2226 *    		int
2227 *     		On success, the number of bytes copied is returned; On error
2228 *		-1 returned.
2229 */
2230
2231/* ARGSUSED */
2232ssize_t
2233fru_get_payload(packet_hdl_t packet, void *buffer, size_t nbytes,
2234    door_cred_t *cred)
2235{
2236	hash_obj_t	*packet_hash_obj;
2237
2238	/* packet hash object */
2239	packet_hash_obj	= lookup_handle_object(packet, PACKET_TYPE);
2240	if (packet_hash_obj == NULL) {
2241		return (-1);
2242	}
2243
2244	/* verify payload length */
2245	if (nbytes != packet_hash_obj->u.pkt_obj->paylen) {
2246		return (-1);
2247	}
2248
2249	(void) memcpy(buffer, packet_hash_obj->u.pkt_obj->payload, nbytes);
2250	return (nbytes);
2251}
2252
2253/*
2254 * Description	:
2255 * 		fru_update_payload() writes the contents of a packet's payload.
2256 *
2257 * Arguments	: packet_hdl_t : packet handle.
2258 *		const void * : data buffer.
2259 *		size_t	: buffer size.
2260 *		packet_hdl_t	: new packet handle.
2261 *
2262 * Return	:
2263 * 		int
2264 *		On success, 0 is returned; on failure
2265 *		-1 is returned.
2266 */
2267
2268int
2269fru_update_payload(packet_hdl_t packet, const void *data, size_t nbytes,
2270    packet_hdl_t *newpacket, door_cred_t *cred)
2271{
2272	int		fd;
2273	int		segment_offset;
2274	int		trailer_offset;
2275	int		retval;
2276	uint32_t	crc;
2277	hash_obj_t	*pkt_hash;
2278	hash_obj_t	*seg_hash;
2279	hash_obj_t	*sec_hash;
2280	hash_obj_t	*cont_hash;
2281	fru_segdesc_t	*desc;
2282
2283	/* check the effective uid of the client */
2284	if (cred->dc_euid != 0) {
2285		errno = EPERM;
2286		return (-1);	/* not a root */
2287	}
2288
2289	/* packet hash object */
2290	pkt_hash = lookup_handle_object(packet,	PACKET_TYPE);
2291	if (pkt_hash == NULL) {
2292		return (-1);
2293	}
2294
2295	/* segment hash object */
2296	seg_hash = lookup_handle_object(pkt_hash->u.pkt_obj->segment_hdl,
2297	    SEGMENT_TYPE);
2298	if (seg_hash == NULL) {
2299		return (-1);
2300	}
2301
2302	/* check for write perm. */
2303	desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
2304	if (!(desc->field.field_perm & SEGMENT_WRITE)) {
2305		errno = EPERM;
2306		return (-1); /* write not allowed */
2307	}
2308
2309	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
2310	    SECTION_TYPE);
2311	if (sec_hash == NULL) {
2312		return (-1);
2313	}
2314
2315	if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
2316		errno = EPERM;
2317		return (-1);		/* read-only section */
2318	}
2319
2320	cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
2321	    CONTAINER_TYPE);
2322	if (cont_hash == NULL) {
2323		return (-1);
2324	}
2325
2326	if (pkt_hash->u.pkt_obj->paylen != nbytes) {
2327		return (-1);
2328	}
2329
2330	(void) memcpy(pkt_hash->u.pkt_obj->payload, (char *)data, nbytes);
2331	fd	= open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
2332	if (fd < 0) {
2333		return (-1);
2334	}
2335
2336	trailer_offset	= seg_hash->u.seg_obj->trailer_offset;
2337	segment_offset	= seg_hash->u.seg_obj->segment.offset;
2338
2339	crc = get_checksum_crc(seg_hash, (trailer_offset - segment_offset));
2340	retval = pwrite(fd, data, nbytes, pkt_hash->u.pkt_obj->payload_offset);
2341	if (retval != nbytes) {
2342		(void) close(fd);
2343		return (-1);
2344	}
2345
2346	retval = pwrite(fd, &crc, sizeof (crc), trailer_offset + 1);
2347	(void) close(fd);
2348	if (retval != sizeof (crc)) {
2349		return (-1);
2350	}
2351	*newpacket	= packet;
2352	return (0);
2353}
2354
2355/*
2356 * Description	:
2357 *		fru_append_packet() appends a packet to a segment.
2358 *
2359 * Arguments	:
2360 *		segment_hdl_t segment
2361 *		A handle for the segment to which the packet will be appended.
2362 *
2363 *   		packet_t *packet
2364 *     		On entry, the "tag" component of "packet" specifies the tag
2365 *     		value for the added packet; the "handle" component is ignored.
2366 *     		On return, the "handle" component is set to the handle of the
2367 *     		appended packet.
2368 *
2369 *   		const void *payload
2370 *     		A pointer to the caller's buffer containing the payload data for
2371 *     		the appended packet.
2372 *
2373 *   		size_t nbytes
2374 *     		The size of the caller buffer.
2375 *
2376 * Return	:
2377 *   		int
2378 *     		On success, 0 is returned; on error -1 is returned;
2379 */
2380
2381int
2382fru_append_packet(segment_hdl_t segment, packet_t *packet, const void *payload,
2383    size_t nbytes, segment_hdl_t *newsegment, door_cred_t *cred)
2384{
2385	int		trailer_offset;
2386	int		tag_size;
2387	int		fd;
2388	int		retval;
2389	char		trailer[] = {0x0c, 0x00, 0x00, 0x00, 0x00};
2390	uint32_t	crc;
2391	hash_obj_t	*seg_hash;
2392	hash_obj_t	*sec_hash;
2393	hash_obj_t	*pkt_hash;
2394	hash_obj_t	*cont_hash;
2395	fru_tagtype_t	tagtype;
2396	fru_segdesc_t	*desc;
2397
2398	/* check the effective uid of the client */
2399	if (cred->dc_euid != 0) {
2400		errno = EPERM;
2401		return (-1);	/* not a root */
2402	}
2403
2404	seg_hash = lookup_handle_object(segment, SEGMENT_TYPE);
2405	if (seg_hash == NULL) {
2406		return (-1);
2407	}
2408
2409	/* check for write perm. */
2410	desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
2411	if (!(desc->field.field_perm & SEGMENT_WRITE)) {
2412		errno = EPERM;
2413		return (-1); /* write not allowed */
2414	}
2415
2416	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
2417	    SECTION_TYPE);
2418	if (sec_hash == NULL) {
2419		return (-1);
2420	}
2421
2422	if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
2423		errno = EPERM;
2424		return (-1);		/* read-only section */
2425	}
2426
2427	trailer_offset	= seg_hash->u.seg_obj->trailer_offset;
2428
2429	/*
2430	 * if trailer offset is 0 than parse the segment data to get the trailer
2431	 * offset to compute the remaining space left in the segment area for
2432	 * new packet to be added.
2433	 */
2434	if (trailer_offset == 0) {
2435		(void) fru_get_num_packets(segment, cred);
2436		trailer_offset  = seg_hash->u.seg_obj->trailer_offset;
2437	}
2438
2439	tagtype	= get_tag_type((void *)&packet->tag);
2440	if (tagtype == -1) {
2441		return (-1);
2442	}
2443
2444	tag_size	= get_tag_size(tagtype);
2445	if (tag_size == -1) {
2446		return (-1);
2447	}
2448
2449	if (seg_hash->u.seg_obj->segment.length >
2450	    ((trailer_offset - seg_hash->u.seg_obj->segment.offset) +
2451	    tag_size + nbytes + sizeof (char) + sizeof (uint32_t))) {
2452		/* create new packet hash */
2453		pkt_hash = create_packet_hash_object();
2454		if (pkt_hash == NULL) {
2455			return (-1);
2456		}
2457
2458		/* tag initialization */
2459		(void) memcpy(&pkt_hash->u.pkt_obj->tag, &packet->tag,
2460		    tag_size);
2461		pkt_hash->u.pkt_obj->tag_size	= tag_size;
2462
2463		/* payload inititalization */
2464		pkt_hash->u.pkt_obj->payload	= malloc(nbytes);
2465		if (pkt_hash->u.pkt_obj->payload == NULL) {
2466			free(pkt_hash);
2467			return (-1);
2468		}
2469
2470		(void) memcpy(pkt_hash->u.pkt_obj->payload, payload, nbytes);
2471		pkt_hash->u.pkt_obj->paylen	= nbytes;
2472		pkt_hash->u.pkt_obj->payload_offset = trailer_offset + tag_size;
2473
2474		/* add to hash table */
2475		add_hashobject_to_hashtable(pkt_hash);
2476
2477		add_to_pkt_object_list(seg_hash, pkt_hash);
2478
2479		cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
2480		    CONTAINER_TYPE);
2481		if (cont_hash == NULL) {
2482			return (-1);
2483		}
2484
2485		fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
2486		if (fd < 0) {
2487			return (-1);
2488		}
2489
2490		/* update the trailer offset  */
2491		trailer_offset += tag_size + nbytes;
2492
2493		/* calculate new checksum */
2494		crc = get_checksum_crc(seg_hash, (trailer_offset -
2495		    seg_hash->u.seg_obj->segment.offset));
2496
2497		retval = pwrite(fd, &packet->tag, tag_size,
2498		    trailer_offset - (tag_size + nbytes));
2499		if (retval != tag_size) {
2500			(void) close(fd);
2501			return (-1);
2502		}
2503
2504		retval = pwrite(fd, payload, nbytes, trailer_offset - nbytes);
2505		if (retval != nbytes) {
2506			(void) close(fd);
2507			return (-1);
2508		}
2509
2510		retval = pwrite(fd, trailer, sizeof (trailer), trailer_offset);
2511		if (retval != sizeof (trailer)) {
2512			(void) close(fd);
2513			return (-1);
2514		}
2515
2516		retval = pwrite(fd, &crc, sizeof (crc), trailer_offset + 1);
2517		(void) close(fd);
2518		if (retval != sizeof (crc)) {
2519			return (-1);
2520		}
2521
2522		seg_hash->u.seg_obj->trailer_offset = trailer_offset;
2523		seg_hash->u.seg_obj->num_of_packets += 1;
2524
2525		*newsegment	= segment; 	/* return new segment handle */
2526		return (0);
2527	} else {
2528		errno = EAGAIN;
2529	}
2530
2531	return (-1);
2532}
2533
2534static void
2535adjust_packets(int	fd, hash_obj_t	*free_obj, hash_obj_t	*object_list)
2536{
2537	int		retval;
2538	uint32_t	new_offset;
2539	hash_obj_t	*hash_ptr;
2540
2541	new_offset = free_obj->u.pkt_obj->payload_offset -
2542	    free_obj->u.pkt_obj->tag_size;
2543	for (hash_ptr = object_list;
2544	    hash_ptr != NULL; hash_ptr = hash_ptr->u.pkt_obj->next) {
2545		retval = pwrite(fd, &hash_ptr->u.pkt_obj->tag,
2546		    hash_ptr->u.pkt_obj->tag_size, new_offset);
2547		if (retval != hash_ptr->u.pkt_obj->tag_size) {
2548			return;
2549		}
2550		new_offset += hash_ptr->u.pkt_obj->tag_size;
2551		hash_ptr->u.pkt_obj->payload_offset = new_offset;
2552		retval = pwrite(fd, hash_ptr->u.pkt_obj->payload,
2553		    hash_ptr->u.pkt_obj->paylen, new_offset);
2554		if (retval != hash_ptr->u.pkt_obj->paylen) {
2555			return;
2556		}
2557		new_offset += hash_ptr->u.pkt_obj->paylen;
2558	}
2559}
2560
2561static void
2562free_packet_object(handle_t	handle, hash_obj_t *seg_hash)
2563{
2564	hash_obj_t	*pkt_hash;
2565	hash_obj_t	*next_hash;
2566
2567	pkt_hash	= seg_hash->u.seg_obj->pkt_obj_list;
2568	if (pkt_hash == NULL) {
2569		return;
2570	}
2571
2572	if (pkt_hash->obj_hdl == handle) {
2573		seg_hash->u.seg_obj->pkt_obj_list = pkt_hash->u.pkt_obj->next;
2574	} else {
2575		while (pkt_hash->obj_hdl != handle) {
2576			next_hash = pkt_hash;
2577			pkt_hash = pkt_hash->u.pkt_obj->next;
2578			if (pkt_hash == NULL) {
2579				return;
2580			}
2581		}
2582		next_hash->u.pkt_obj->next = pkt_hash->u.pkt_obj->next;
2583	}
2584
2585	if (pkt_hash->prev == NULL) {
2586		hash_table[(pkt_hash->obj_hdl % TABLE_SIZE)] = pkt_hash->next;
2587		if (pkt_hash->next != NULL) {
2588			pkt_hash->next->prev = NULL;
2589		}
2590	} else {
2591		pkt_hash->prev->next = pkt_hash->next;
2592		if (pkt_hash->next != NULL) {
2593			pkt_hash->next->prev = pkt_hash->prev;
2594		}
2595	}
2596
2597	free(pkt_hash->u.pkt_obj->payload);
2598	free(pkt_hash->u.pkt_obj);
2599	free(pkt_hash);
2600}
2601
2602/*
2603 * Description	:
2604 *   		fru_delete_packet() deletes a packet from a segment.
2605 *
2606 * Arguments	: packet_hdl_t : packet number to be deleted.
2607 *		segment_hdl_t : new segment handler.
2608 *
2609 * Return	:
2610 *   		int
2611 *     		On success, 0 is returned; on error, -1.
2612 *
2613 * NOTES
2614 * 		Packets are adjacent; thus, deleting a packet requires moving
2615 *   		succeeding packets to compact the resulting hole.
2616 */
2617
2618int
2619fru_delete_packet(packet_hdl_t packet, segment_hdl_t *newsegment,
2620    door_cred_t *cred)
2621{
2622	int		retval;
2623	int		fd;
2624	char		trailer[] = { 0x0c, 0x00, 0x00, 0x00, 0x00};
2625	uint32_t	crc;
2626	hash_obj_t	*tmp_obj;
2627	hash_obj_t	*pkt_hash;
2628	hash_obj_t	*sec_hash;
2629	hash_obj_t	*cont_hash;
2630	hash_obj_t	*prev_obj;
2631	hash_obj_t	*seg_hash;
2632	fru_segdesc_t	*desc;
2633
2634	/* check the effective uid of the client */
2635	if (cred->dc_euid != 0) {
2636		errno = EPERM;
2637		return (-1);	/* not a root */
2638	}
2639
2640	/* packet hash object */
2641	pkt_hash = lookup_handle_object(packet, PACKET_TYPE);
2642	if (pkt_hash == NULL) {
2643		return (-1);
2644	}
2645
2646	/* segment hash object */
2647	seg_hash = lookup_handle_object(pkt_hash->u.pkt_obj->segment_hdl,
2648	    SEGMENT_TYPE);
2649	if (seg_hash == NULL) {
2650		return (-1);
2651	}
2652
2653	/* check for write perm. */
2654	desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
2655	if (!(desc->field.field_perm & SEGMENT_WRITE)) {
2656		errno = EPERM;
2657		return (-1); /* write not allowed */
2658	}
2659
2660	/* section hash object */
2661	sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
2662	    SECTION_TYPE);
2663	if (sec_hash == NULL) {
2664		return (-1);
2665	}
2666
2667	if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
2668		errno = EPERM;
2669		return (-1); 		/* read-only section */
2670	}
2671
2672	prev_obj	= seg_hash->u.seg_obj->pkt_obj_list;
2673	if (prev_obj == NULL) {
2674		return (-1);
2675	}
2676
2677	/* container hash object */
2678	cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
2679	    CONTAINER_TYPE);
2680	if (cont_hash == NULL) {
2681		return (-1);
2682	}
2683
2684	fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
2685	if (fd < 0) {
2686		return (-1);
2687	}
2688
2689	if (prev_obj->obj_hdl == packet) { /* first object to be deleted */
2690		adjust_packets(fd, prev_obj, prev_obj->u.pkt_obj->next);
2691		seg_hash->u.seg_obj->trailer_offset -=
2692		    (prev_obj->u.pkt_obj->tag_size +
2693		    prev_obj->u.pkt_obj->paylen);
2694		free_packet_object(packet, seg_hash);
2695	} else {
2696		for (tmp_obj = prev_obj;
2697		    tmp_obj != NULL; tmp_obj = tmp_obj->u.pkt_obj->next) {
2698			/* found the object */
2699			if (tmp_obj->obj_hdl == packet) {
2700				adjust_packets(fd, tmp_obj,
2701				    tmp_obj->u.pkt_obj->next);
2702				seg_hash->u.seg_obj->trailer_offset -=
2703				    (tmp_obj->u.pkt_obj->tag_size +
2704				    tmp_obj->u.pkt_obj->paylen);
2705				free_packet_object(packet, seg_hash);
2706			}
2707		}
2708	}
2709
2710	seg_hash->u.seg_obj->num_of_packets -= 1;
2711
2712	/* calculate checksum */
2713	crc = get_checksum_crc(seg_hash, (seg_hash->u.seg_obj->trailer_offset -
2714	    seg_hash->u.seg_obj->segment.offset));
2715	/* write trailer at new offset */
2716	retval = pwrite(fd, &trailer, sizeof (trailer),
2717	    seg_hash->u.seg_obj->trailer_offset);
2718	if (retval != sizeof (trailer)) {
2719		(void) close(fd);
2720		return (-1);
2721	}
2722
2723	/* write the checksum value */
2724	retval = pwrite(fd, &crc, sizeof (crc),
2725	    seg_hash->u.seg_obj->trailer_offset + 1);
2726	(void) close(fd);
2727	if (retval != sizeof (crc)) {
2728		return (-1);
2729	}
2730
2731	*newsegment = seg_hash->obj_hdl; /* return new segment handle */
2732	return (0);
2733}
2734
2735/*
2736 * Description :
2737 *		fru_close_container() removes the association between a
2738 *		container and its handle. this routines free's up all the
2739 *		hash object contained under container.
2740 *
2741 * Arguments   :
2742 *		container_hdl_t holds the file descriptor of the fru.
2743 *
2744 * Return      :
2745 *		int
2746 *		return 0.
2747 *
2748 */
2749
2750/* ARGSUSED */
2751int
2752fru_close_container(container_hdl_t container)
2753{
2754	hash_obj_t	*hash_obj;
2755	hash_obj_t	*prev_hash;
2756	hash_obj_t	*sec_hash_obj;
2757	handle_t	obj_hdl;
2758
2759	/* lookup for container hash object */
2760	hash_obj = lookup_handle_object(container, CONTAINER_TYPE);
2761	if (hash_obj == NULL) {
2762		return (0);
2763	}
2764
2765	/* points to section object list */
2766	sec_hash_obj = hash_obj->u.cont_obj->sec_obj_list;
2767
2768	/* traverse section object list */
2769	while (sec_hash_obj != NULL) {
2770
2771		/* traverse segment hash object in the section */
2772		while (sec_hash_obj->u.sec_obj->seg_obj_list != NULL) {
2773			/* object handle of the segment hash object */
2774			obj_hdl	=
2775			    sec_hash_obj->u.sec_obj->seg_obj_list->obj_hdl;
2776			free_segment_hash(obj_hdl, sec_hash_obj);
2777		}
2778
2779		/* going to free section hash object, relink the hash object */
2780		if (sec_hash_obj->prev == NULL) {
2781			hash_table[(sec_hash_obj->obj_hdl % TABLE_SIZE)] =
2782			    sec_hash_obj->next;
2783			if (sec_hash_obj->next != NULL) {
2784				sec_hash_obj->next->prev = NULL;
2785			}
2786		} else {
2787			sec_hash_obj->prev->next = sec_hash_obj->next;
2788			if (sec_hash_obj->next != NULL) {
2789				sec_hash_obj->next->prev = sec_hash_obj->prev;
2790			}
2791		}
2792
2793		prev_hash = sec_hash_obj;
2794
2795		sec_hash_obj = sec_hash_obj->u.sec_obj->next;
2796
2797		free(prev_hash->u.sec_obj); /* free section hash object */
2798		free(prev_hash); /* free section hash */
2799	}
2800
2801	/* free container hash object */
2802	if (hash_obj->prev == NULL) {
2803		hash_table[(hash_obj->obj_hdl % TABLE_SIZE)] = hash_obj->next;
2804		if (hash_obj->next != NULL) {
2805			hash_obj->next->prev = NULL;
2806		}
2807	} else {
2808		hash_obj->prev->next = hash_obj->next;
2809		if (hash_obj->next != NULL) {
2810			hash_obj->next->prev = hash_obj->prev;
2811		}
2812	}
2813
2814	free(hash_obj->u.cont_obj);
2815	free(hash_obj);
2816	return (0);
2817}
2818
2819/*
2820 * Description :
2821 *		fru_is_data_available() checks to see if the frudata
2822 *		is available on a fru.
2823 *
2824 * Arguments   :
2825 *		picl_nodehdl_t holds the picl node handle of the fru.
2826 *
2827 * Return      :
2828 *		int
2829 *		return 1: if FRUID information is available
2830 *		return 0: if FRUID information is not present
2831 *
2832 */
2833
2834/* ARGSUSED */
2835int
2836fru_is_data_available(picl_nodehdl_t fru)
2837{
2838	return (0);
2839}
2840