OSDev.org

Code: Select all

int umap_local(register struct proc *rp, int seg, int vir_addr, int bytes) 
{ 
/* Calculate the physical memory address for a given virtual address. */ 
int vc; /* the virtual address in clicks */ 
int pa; /* intermediate variables as phys_bytes */ 

#if (CHIP == INTEL)   //Check for x86 CPU
int seg_base;
#endif 

/* If 'seg' is D it could really be S and vice versa. T really means T. 
* If the virtual address falls in the gap, it causes a problem. On the 
* 8088 it is probably a legal stack reference, since "stackfaults" are 
* not detected by the hardware. On 8088s, the gap is called S and 
* accepted, but on other machines it is called D and rejected. 
* The Atari ST behaves like the 8088 in this respect. 
*/ 

if (bytes <= 0) return 0;
if (vir_addr + bytes <= vir_addr) return 0; /* overflow */

//This just gets a page count basically
vc = (vir_addr + bytes - 1) >> CLICK_SHIFT;


#if (CHIP == INTEL) || (CHIP == M68000) 
if (seg != T)   //Not a T type segment?
{
  if (vc < rp->p_memmap[D].mem_vir + rp->p_memmap[D].mem_len)
   seg = D;
  else
   seg = S;
//Made this simpler to read :)  Just checks if it's within this range of D segment
//  seg = (vc < rp->p_memmap[D].mem_vir + rp->p_memmap[D].mem_len ? D : S); 
}
#else 
if (seg != T) 
{
  if (vc < rp->p_memmap[S].mem_vir) //Is it less than this segment's start?
    seg = D;
  else
    seg = S;
//And again for readability
//  seg = (vc < rp->p_memmap[S].mem_vir ? D : S); 
}
#endif 

//Check if the virtual address is within our segment
if ((vir_addr>>CLICK_SHIFT) >= rp->p_memmap[seg].mem_vir + 
rp->p_memmap[seg].mem_len) return 0;

//Check if vc is within our segment
if (vc >= rp->p_memmap[seg].mem_vir + 
rp->p_memmap[seg].mem_len) return 0;

#if (CHIP == INTEL)  //if x86
seg_base = rp->p_memmap[seg].mem_phys;  //Grab the physical page#
seg_base = seg_base << CLICK_SHIFT; //Calculate the physical address from page #
#endif 
pa = vir_addr;   //Store vir_addr for a minute
#if (CHIP != M68000)  //all but the Motorola 68000
//Subtract this segments virtual address from the virtual address passed in
pa -= rp->p_memmap[seg].mem_vir << CLICK_SHIFT; 
return seg_base + pa;  //Return the physical address (seg_base) and the offset into the segment
#endif 
#if (CHIP == M68000)  //Otherwise for the motorola 68000
pa -= (phys_bytes)rp->p_memmap[seg].mem_vir << CLICK_SHIFT; 
//Same as above, excent we want to add the physical start of the segment after we're done, since INTEL chips had seg_base to do this, we don't
pa += (phys_bytes)rp->p_memmap[seg].mem_phys << CLICK_SHIFT; 
return pa;
#endif

Code: Select all

int umap_local(register struct proc *rp, int seg, int vir_addr, int bytes) 
{ 

/* Calculate the physical memory address for a given virtual address. */ 
int vc; /* the virtual address in clicks */ 
int pa; /* intermediate variables as phys_bytes */ 
int seg_base;

if (bytes <= 0) return 0; //Return NULL
if (vir_addr + bytes <= vir_addr) return 0; /* overflow */

//This just gets a page count basically
//Gets the LAST Page index of this mapping
vc = (vir_addr + bytes - 1) >> CLICK_SHIFT;

if (seg != T)   //Not a T type segment?
{  //Determine if it's a D or S segment
  if (vc < rp->p_memmap[D].mem_vir + rp->p_memmap[D].mem_len)
   seg = D;
  else
   seg = S;
}

//Check if the starting virtual address is within this segment
if ((vir_addr>>CLICK_SHIFT) >= rp->p_memmap[seg].mem_vir + 
rp->p_memmap[seg].mem_len) return 0; ///Return NULL

//Check if vc is within our segment (vc was our page index calculated based on vir_addr + bytes), aka, our ending page index!
if (vc >= rp->p_memmap[seg].mem_vir + 
rp->p_memmap[seg].mem_len) return 0;  //return NULL

/* Ok, at this point, we know which segment we're in, and that the entire range vir_addr -> vir_addr+bytes is within this segment */

seg_base = rp->p_memmap[seg].mem_phys;  //Grab the physical page #
seg_base = seg_base << CLICK_SHIFT; //Calculate the physical address from page #

pa = vir_addr;   //Grab vir_addr into a variable
//Subtract this segments virtual address from the virtual address passed in, basically gives us offset into this segment
pa -= rp->p_memmap[seg].mem_vir << CLICK_SHIFT;
return seg_base + pa;  //Return the physical address (seg_base) and the offset into the segment

Code: Select all

...