Lines Matching defs:segp
78 #define SEG_OFFSET(SEGP, ADDR) ((char *)(ADDR) - (char *)(SEGP->seg_start))
98 segment_t *segp = (segment_t *) calloc(1, sizeof(segment_t));
100 if (segp == NULL)
103 return segp;
112 segment_t *segp, **segpp;
117 segp = gcp->seg_avail;
118 if (segp != NULL) {
120 return segp;
126 for (segpp = gcp->seglist; (segp = *segpp); ++segpp) {
127 if (segp->seg_type == SEGT_NONE)
128 return segp;
135 *segpp = segp = new_segment();
136 segp->seg_slot = segpp - gcp->seglist;
137 return segp;
144 static void unmap_segment(segment_t * segp)
147 if (segp->seg_start == MAP_FAILED)
150 switch (segp->seg_type) {
153 munmap(segp->seg_start, segp->seg_length);
157 shmdt(segp->seg_start);
165 segp->seg_start = MAP_FAILED;
173 static void free_seg_slot(segment_t * segp)
176 int slot = segp->seg_slot;
178 if (segp->seg_name != NULL)
179 free(segp->seg_name);
181 if (segp->seg_path != NULL)
182 free(segp->seg_path);
184 if (segp->seg_type == SEGT_FILE && segp->seg_fd != SEG_FD_NONE)
185 close(segp->seg_fd);
187 if (segp->seg_type == SEGT_SHM && segp->seg_shmid != SHM_ID_NONE)
188 shmctl(segp->seg_shmid, IPC_RMID, NULL);
190 (void)memset(segp, 0, sizeof(*segp));
192 segp->seg_slot = slot;
194 gcp->seg_avail = segp;
204 segment_t *segp, **segpp;
210 for (; (segp = *segpp); ++segpp) {
211 if (segp->seg_type != SEGT_SHM) {
214 free_seg_slot(segp); /* to remove shared mem */
254 static int map_anon_segment(segment_t * segp)
259 int flags = segp->seg_flags;
264 memp = (char *)mmap(0, segp->seg_length, segp->seg_prot, flags | MAP_ANONYMOUS, 0, /* fd -- ignored */
275 gcp->program_name, segp->seg_name,
276 memp, memp + segp->seg_length - 1);
278 segp->seg_start = memp;
287 static int open_file(segment_t * segp)
294 if (stat(segp->seg_path, &stbuf) < 0) {
297 gcp->program_name, segp->seg_path, strerror(err));
298 free_seg_slot(segp);
307 gcp->program_name, segp->seg_path);
308 free_seg_slot(segp);
316 if (!access(segp->seg_path, R_OK | W_OK))
318 else if (!access(segp->seg_path, R_OK)) {
320 segp->seg_prot &= ~PROT_WRITE;
321 } else if (!access(segp->seg_path, W_OK)) {
323 segp->seg_prot &= ~PROT_READ;
326 gcp->program_name, segp->seg_path);
327 free_seg_slot(segp);
331 fd = open(segp->seg_path, flags);
335 gcp->program_name, segp->seg_path, strerror(err));
336 free_seg_slot(segp);
340 segp->seg_fd = fd;
361 static int map_file_segment(segment_t * segp)
368 int flags = segp->seg_flags;
373 if ((fd = segp->seg_fd) == SEG_FD_NONE) {
375 gcp->program_name, segp->seg_path);
384 segp->seg_offset = round_down_to_pagesize(segp->seg_offset);
385 if (segp->seg_offset > size) {
387 gcp->program_name, segp->seg_offset, segp->seg_path);
391 if (segp->seg_length == 0)
392 segp->seg_length = round_up_to_pagesize(size) -
393 segp->seg_offset;
395 segp->seg_length = round_up_to_pagesize(segp->seg_length);
397 memp = (char *)mmap(0, segp->seg_length,
398 segp->seg_prot, flags, fd, segp->seg_offset);
403 __FUNCTION__, segp->seg_path, strerror(err));
408 gcp->program_name, segp->seg_name,
409 memp, memp + segp->seg_length - 1);
411 segp->seg_start = memp;
419 static int get_shm_segment(segment_t * segp)
425 shmid = shmget(IPC_PRIVATE, segp->seg_length, SHM_R | SHM_W);
429 gcp->program_name, segp->seg_name, strerror(err));
430 free_seg_slot(segp);
434 segp->seg_shmid = shmid;
436 gcp->program_name, segp->seg_name, segp->seg_shmid);
443 static int map_shm_segment(segment_t * segp)
447 segp->seg_start = shmat(segp->seg_shmid, NULL, 0);
448 if (segp->seg_start == MAP_FAILED) {
451 gcp->program_name, segp->seg_name, strerror(err));
456 gcp->program_name, segp->seg_name,
457 segp->seg_start, segp->seg_start + segp->seg_length - 1);
473 segment_t *segp, **segpp;
475 for (segpp = gcp->seglist; (segp = *segpp); ++segpp) {
476 if (segp->seg_type == SEGT_NONE) {
481 if (!strcmp(name, segp->seg_name))
482 return segp;
489 *segpp = segp = new_segment();
490 if (segp != NULL) {
491 segp->seg_slot = segpp - gcp->seglist;
492 gcp->seg_avail = segp;
509 segment_t *segp;
512 segp = segment_get(basename(name)); /* ensure unique name */
513 if (segp != NULL) {
515 gcp->program_name, segp->seg_name);
519 segp = get_seg_slot();
520 if (segp == NULL)
524 segp->seg_name = strdup(basename(name));
525 segp->seg_start = MAP_FAILED;
526 segp->seg_length = round_up_to_pagesize(range->length);
527 segp->seg_offset = round_down_to_pagesize(range->offset);
528 segp->seg_type = type;
529 segp->seg_flags = flags; /* possibly 0 */
530 segp->seg_prot = PROT_READ | PROT_WRITE; /* default */
531 segp->seg_fd = SEG_FD_NONE;
532 segp->seg_shmid = SHM_ID_NONE;
540 segp->seg_path = path;
541 return open_file(segp);
546 return get_shm_segment(segp);
560 static int show_one_segment(segment_t * segp, bool header)
564 switch (segp->seg_prot & (PROT_READ | PROT_WRITE)) {
582 if (segp->seg_flags)
583 share = (segp->seg_flags & MAP_SHARED) ? "shared " : "private";
587 name = (segp->seg_type == SEGT_FILE) ? segp->seg_path : segp->seg_name;
592 if (segp->seg_start != MAP_FAILED) {
594 seg_type[segp->seg_type],
595 segp->seg_start,
596 segp->seg_length,
597 segp->seg_offset, protection, share, name);
600 seg_type[segp->seg_type],
601 segp->seg_length,
602 segp->seg_offset, protection, share, name);
614 segment_t *segp, **segpp;
618 segp = segment_get(name);
619 if (segp == NULL) {
624 show_one_segment(segp, false);
632 for (segpp = gcp->seglist; (segp = *segpp); ++segpp) {
633 if (segp->seg_type != SEGT_NONE) {
634 show_one_segment(segp, header);
649 segment_t *segp;
651 segp = segment_get(name);
652 if (segp == NULL) {
658 unmap_segment(segp);
660 free_seg_slot(segp);
674 segment_t *segp;
680 segp = segment_get(name);
681 if (segp == NULL) {
688 if (offset >= segp->seg_length) {
694 memp = (unsigned long *)(segp->seg_start + offset);
695 maxlength = segp->seg_length - offset;
725 segment_t *segp;
727 segp = segment_get(name);
728 if (segp == NULL) {
734 if (segp->seg_start == MAP_FAILED)
737 switch (segp->seg_type) {
740 segp->seg_start, segp->seg_length);
751 segp->seg_start = MAP_FAILED;
764 segment_t *segp;
766 segp = segment_get(name);
767 if (segp == NULL) {
773 if (segp->seg_start != MAP_FAILED) {
780 segp->seg_flags = flags;
782 switch (segp->seg_type) {
784 return map_anon_segment(segp);
789 segp->seg_offset = range->offset;
790 segp->seg_length = range->length;
792 return map_file_segment(segp);
796 return map_shm_segment(segp);
817 segment_t *segp;
823 segp = segment_get(name);
824 if (segp == NULL) {
830 if (segp->seg_start == MAP_FAILED) {
837 if (offset >= segp->seg_length) {
843 start = segp->seg_start + offset;
844 maxlength = segp->seg_length - offset;
856 ret = mbind(segp->seg_start + offset, length, policy, nodemask->n,
879 segment_t *segp;
886 segp = segment_get(name);
887 if (segp == NULL) {
893 if (segp->seg_start == MAP_FAILED) {
900 if (offset >= segp->seg_length) {
906 apage = segp->seg_start + offset;
907 maxlength = segp->seg_length - offset;
922 show_one_segment(segp, false); /* show mapping, no header */
949 gcp->program_name, name, SEG_OFFSET(segp,
