Solaris

/**************************************************************
 * function: write_heap
 * args: map_fd  -- file descriptor for map file
 *       data_fd -- file descriptor for data file
 * returns: no. of chunks written on success, -1 on failure
 * side effects: writes all included segments of the heap to ckpt files
 * misc.: If we are forking and copyonwrite is set, we will write the
          heap from bottom to top, moving the brk pointer up each time
          so that we don't get a page copied if the
 * called from: take_ckpt()
 *************************************************************/
static int write_heap(int map_fd, int data_fd)
{
  Dlist curptr, endptr;
  int no_chunks=0, pn;
  long size;
  caddr_t stop, addr;

  if(ckptflags.incremental){       /*-- incremental checkpointing on? --*/
    endptr = ckptglobals.inc_list->main->flink;
 
    /*-- for each included chunk of the heap --*/
    for(curptr = ckptglobals.inc_list->main->blink->blink;
        curptr != endptr; curptr = curptr->blink){

      /*-- write out the last page in the included chunk --*/
      stop = curptr->addr;
      pn = ((long)curptr->stop - (long)sys.DATASTART) / PAGESIZE;

      if(isdirty(pn)){ 
        addr = (caddr_t)max((long)curptr->addr,
                            (long)((pn * PAGESIZE) + sys.DATASTART));
        size = (long)curptr->stop - (long)addr;

        debug(stderr, "DEBUG: Writing heap from 0x%x to 0x%x, pn = %d\n",
                                                   addr, addr+size, pn);
        if(write_chunk(addr, size, map_fd, data_fd) == -1){
          return -1;
        }

        if((int)addr > (int)(&end) && ckptflags.enhanced_fork){
          brk(addr);
        }
        no_chunks++;
      }

      /*-- write out all the whole pages in the middle of the chunk --*/
      for(pn--; pn * PAGESIZE + sys.DATASTART >= stop; pn--){
        if(isdirty(pn)){
          addr = (caddr_t)((pn * PAGESIZE) + sys.DATASTART);
          debug(stderr, "DEBUG: Writing heap from 0x%x to 0x%x, pn = %d\n",
                                                 addr, addr+PAGESIZE, pn);
          if(write_chunk(addr, PAGESIZE, map_fd, data_fd) == -1){
            return -1;
          }
          if((int)addr > (int)(&end) && ckptflags.enhanced_fork){
            brk(addr);
          }
          no_chunks++;
        }
      }

      /*-- write out the first page in the included chunk --*/
      addr = curptr->addr;
      size = ((pn+1) * PAGESIZE + sys.DATASTART) - addr;

      if(size > 0 && (isdirty(pn))){
        debug(stderr, "DEBUG: Writing heap from 0x%x to 0x%x\n", addr, addr+size);
        if(write_chunk(addr, size, map_fd, data_fd) == -1){
          return -1;
        }

        if((int)addr > (int)(&end) && ckptflags.enhanced_fork){
          brk(addr);
        }
        no_chunks++;
      }
    }
  }
  else{  /*-- incremental checkpointing off! --*/
    endptr = ckptglobals.inc_list->main->blink;

    /*-- for each included chunk of the heap --*/
    for(curptr = ckptglobals.inc_list->main->flink->flink;
        curptr != endptr; curptr = curptr->flink){
      debug(stderr, "DEBUG: saving memory from 0x%x to 0x%x\n", 
                         curptr->addr, curptr->addr+curptr->size);

      if(write_chunk(curptr->addr, curptr->size, map_fd, data_fd) == -1){
        return -1;
      }
      if((int)addr > (int)(&end) && ckptflags.enhanced_fork){
        brk(addr);
      }
      no_chunks++;
    }
  }

  return no_chunks;
}