root/mm/mmap.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. do_mmap
  2. sys_mmap
  3. unmap_fixup
  4. sys_mprotect
  5. sys_munmap
  6. do_munmap
  7. generic_mmap
  8. insert_vm_struct
  9. merge_segments
  10. anon_map
  11. ignoff_mergep

   1 /*
   2  *      linux/mm/mmap.c
   3  *
   4  * Written by obz.
   5  */
   6 #include <linux/stat.h>
   7 #include <linux/sched.h>
   8 #include <linux/kernel.h>
   9 #include <linux/mm.h>
  10 #include <linux/shm.h>
  11 #include <linux/errno.h>
  12 #include <linux/mman.h>
  13 #include <linux/string.h>
  14 #include <linux/malloc.h>
  15 
  16 #include <asm/segment.h>
  17 #include <asm/system.h>
  18 
  19 static int anon_map(struct inode *, struct file *,
  20                     unsigned long, size_t, int,
  21                     unsigned long);
  22 /*
  23  * description of effects of mapping type and prot in current implementation.
  24  * this is due to the current handling of page faults in memory.c. the expected
  25  * behavior is in parens:
  26  *
  27  * map_type     prot
  28  *              PROT_NONE       PROT_READ       PROT_WRITE      PROT_EXEC
  29  * MAP_SHARED   r: (no) yes     r: (yes) yes    r: (no) yes     r: (no) no
  30  *              w: (no) yes     w: (no) copy    w: (yes) yes    w: (no) no
  31  *              x: (no) no      x: (no) no      x: (no) no      x: (yes) no
  32  *              
  33  * MAP_PRIVATE  r: (no) yes     r: (yes) yes    r: (no) yes     r: (no) no
  34  *              w: (no) copy    w: (no) copy    w: (copy) copy  w: (no) no
  35  *              x: (no) no      x: (no) no      x: (no) no      x: (yes) no
  36  *
  37  */
  38 
  39 #define CODE_SPACE(addr)        \
  40  (PAGE_ALIGN(addr) < current->start_code + current->end_code)
  41 
  42 int do_mmap(struct file * file, unsigned long addr, unsigned long len,
     /* [previous][next][first][last][top][bottom][index][help] */
  43         unsigned long prot, unsigned long flags, unsigned long off)
  44 {
  45         int mask, error;
  46 
  47         if ((len = PAGE_ALIGN(len)) == 0)
  48                 return addr;
  49 
  50         if (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
  51                 return -EINVAL;
  52 
  53         /*
  54          * do simple checking here so the lower-level routines won't have
  55          * to. we assume access permissions have been handled by the open
  56          * of the memory object, so we don't do any here.
  57          */
  58 
  59         if (file != NULL)
  60                 switch (flags & MAP_TYPE) {
  61                 case MAP_SHARED:
  62                         if ((prot & PROT_WRITE) && !(file->f_mode & 2))
  63                                 return -EACCES;
  64                         /* fall through */
  65                 case MAP_PRIVATE:
  66                         if (!(file->f_mode & 1))
  67                                 return -EACCES;
  68                         break;
  69 
  70                 default:
  71                         return -EINVAL;
  72                 }
  73         /*
  74          * obtain the address to map to. we verify (or select) it and ensure
  75          * that it represents a valid section of the address space.
  76          */
  77 
  78         if (flags & MAP_FIXED) {
  79                 if (addr & ~PAGE_MASK)
  80                         return -EINVAL;
  81                 if (len > TASK_SIZE || addr > TASK_SIZE - len)
  82                         return -EINVAL;
  83         } else {
  84                 struct vm_area_struct * vmm;
  85 
  86                 /* Maybe this works.. Ugly it is. */
  87                 addr = SHM_RANGE_START;
  88                 while (addr+len < SHM_RANGE_END) {
  89                         for (vmm = current->mm->mmap ; vmm ; vmm = vmm->vm_next) {
  90                                 if (addr >= vmm->vm_end)
  91                                         continue;
  92                                 if (addr + len <= vmm->vm_start)
  93                                         continue;
  94                                 addr = PAGE_ALIGN(vmm->vm_end);
  95                                 break;
  96                         }
  97                         if (!vmm)
  98                                 break;
  99                 }
 100                 if (addr+len >= SHM_RANGE_END)
 101                         return -ENOMEM;
 102         }
 103 
 104         /*
 105          * determine the object being mapped and call the appropriate
 106          * specific mapper. the address has already been validated, but
 107          * not unmapped, but the maps are removed from the list.
 108          */
 109         if (file && (!file->f_op || !file->f_op->mmap))
 110                 return -ENODEV;
 111         mask = 0;
 112         if (prot & (PROT_READ | PROT_EXEC))
 113                 mask |= PAGE_READONLY;
 114         if (prot & PROT_WRITE)
 115                 if ((flags & MAP_TYPE) == MAP_PRIVATE)
 116                         mask |= PAGE_COPY;
 117                 else
 118                         mask |= PAGE_SHARED;
 119         if (!mask)
 120                 return -EINVAL;
 121 
 122         do_munmap(addr, len);   /* Clear old maps */
 123 
 124         if (file)
 125                 error = file->f_op->mmap(file->f_inode, file, addr, len, mask, off);
 126         else
 127                 error = anon_map(NULL, NULL, addr, len, mask, off);
 128         
 129         if (!error)
 130                 return addr;
 131 
 132         if (!current->errno)
 133                 current->errno = -error;
 134         return -1;
 135 }
 136 
 137 asmlinkage int sys_mmap(unsigned long *buffer)
     /* [previous][next][first][last][top][bottom][index][help] */
 138 {
 139         int error;
 140         unsigned long flags;
 141         struct file * file = NULL;
 142 
 143         error = verify_area(VERIFY_READ, buffer, 6*4);
 144         if (error)
 145                 return error;
 146         flags = get_fs_long(buffer+3);
 147         if (!(flags & MAP_ANONYMOUS)) {
 148                 unsigned long fd = get_fs_long(buffer+4);
 149                 if (fd >= NR_OPEN || !(file = current->files->fd[fd]))
 150                         return -EBADF;
 151         }
 152         return do_mmap(file, get_fs_long(buffer), get_fs_long(buffer+1),
 153                 get_fs_long(buffer+2), flags, get_fs_long(buffer+5));
 154 }
 155 
 156 /*
 157  * Normal function to fix up a mapping
 158  * This function is the default for when an area has no specific
 159  * function.  This may be used as part of a more specific routine.
 160  * This function works out what part of an area is affected and
 161  * adjusts the mapping information.  Since the actual page
 162  * manipulation is done in do_mmap(), none need be done here,
 163  * though it would probably be more appropriate.
 164  *
 165  * By the time this function is called, the area struct has been
 166  * removed from the process mapping list, so it needs to be
 167  * reinserted if necessary.
 168  *
 169  * The 4 main cases are:
 170  *    Unmapping the whole area
 171  *    Unmapping from the start of the segment to a point in it
 172  *    Unmapping from an intermediate point to the end
 173  *    Unmapping between to intermediate points, making a hole.
 174  *
 175  * Case 4 involves the creation of 2 new areas, for each side of
 176  * the hole.
 177  */
 178 void unmap_fixup(struct vm_area_struct *area,
     /* [previous][next][first][last][top][bottom][index][help] */
 179                  unsigned long addr, size_t len)
 180 {
 181         struct vm_area_struct *mpnt;
 182         unsigned long end = addr + len;
 183 
 184         if (addr < area->vm_start || addr >= area->vm_end ||
 185             end <= area->vm_start || end > area->vm_end ||
 186             end < addr)
 187         {
 188                 printk("unmap_fixup: area=%lx-%lx, unmap %lx-%lx!!\n",
 189                        area->vm_start, area->vm_end, addr, end);
 190                 return;
 191         }
 192 
 193         /* Unmapping the whole area */
 194         if (addr == area->vm_start && end == area->vm_end) {
 195                 if (area->vm_ops && area->vm_ops->close)
 196                         area->vm_ops->close(area);
 197                 return;
 198         }
 199 
 200         /* Work out to one of the ends */
 201         if (addr >= area->vm_start && end == area->vm_end)
 202                 area->vm_end = addr;
 203         if (addr == area->vm_start && end <= area->vm_end) {
 204                 area->vm_offset += (end - area->vm_start);
 205                 area->vm_start = end;
 206         }
 207 
 208         /* Unmapping a hole */
 209         if (addr > area->vm_start && end < area->vm_end)
 210         {
 211                 /* Add end mapping -- leave beginning for below */
 212                 mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL);
 213 
 214                 *mpnt = *area;
 215                 mpnt->vm_offset += (end - area->vm_start);
 216                 mpnt->vm_start = end;
 217                 if (mpnt->vm_inode)
 218                         mpnt->vm_inode->i_count++;
 219                 insert_vm_struct(current, mpnt);
 220                 area->vm_end = addr;    /* Truncate area */
 221         }
 222 
 223         /* construct whatever mapping is needed */
 224         mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL);
 225         *mpnt = *area;
 226         insert_vm_struct(current, mpnt);
 227 }
 228 
 229 
 230 asmlinkage int sys_mprotect(unsigned long addr, size_t len, unsigned long prot)
     /* [previous][next][first][last][top][bottom][index][help] */
 231 {
 232         return -EINVAL; /* Not implemented yet */
 233 }
 234 
 235 asmlinkage int sys_munmap(unsigned long addr, size_t len)
     /* [previous][next][first][last][top][bottom][index][help] */
 236 {
 237         return do_munmap(addr, len);
 238 }
 239 
 240 /*
 241  * Munmap is split into 2 main parts -- this part which finds
 242  * what needs doing, and the areas themselves, which do the
 243  * work.  This now handles partial unmappings.
 244  * Jeremy Fitzhardine <jeremy@sw.oz.au>
 245  */
 246 int do_munmap(unsigned long addr, size_t len)
     /* [previous][next][first][last][top][bottom][index][help] */
 247 {
 248         struct vm_area_struct *mpnt, **npp, *free;
 249 
 250         if ((addr & ~PAGE_MASK) || addr > TASK_SIZE || len > TASK_SIZE-addr)
 251                 return -EINVAL;
 252 
 253         if ((len = PAGE_ALIGN(len)) == 0)
 254                 return 0;
 255 
 256         /*
 257          * Check if this memory area is ok - put it on the temporary
 258          * list if so..  The checks here are pretty simple --
 259          * every area affected in some way (by any overlap) is put
 260          * on the list.  If nothing is put on, nothing is affected.
 261          */
 262         npp = &current->mm->mmap;
 263         free = NULL;
 264         for (mpnt = *npp; mpnt != NULL; mpnt = *npp) {
 265                 unsigned long end = addr+len;
 266 
 267                 if ((addr < mpnt->vm_start && end <= mpnt->vm_start) ||
 268                     (addr >= mpnt->vm_end && end > mpnt->vm_end))
 269                 {
 270                         npp = &mpnt->vm_next;
 271                         continue;
 272                 }
 273 
 274                 *npp = mpnt->vm_next;
 275                 mpnt->vm_next = free;
 276                 free = mpnt;
 277         }
 278 
 279         if (free == NULL)
 280                 return 0;
 281 
 282         /*
 283          * Ok - we have the memory areas we should free on the 'free' list,
 284          * so release them, and unmap the page range..
 285          * If the one of the segments is only being partially unmapped,
 286          * it will put new vm_area_struct(s) into the address space.
 287          */
 288         while (free) {
 289                 unsigned long st, end;
 290 
 291                 mpnt = free;
 292                 free = free->vm_next;
 293 
 294                 st = addr < mpnt->vm_start ? mpnt->vm_start : addr;
 295                 end = addr+len;
 296                 end = end > mpnt->vm_end ? mpnt->vm_end : end;
 297 
 298                 if (mpnt->vm_ops && mpnt->vm_ops->unmap)
 299                         mpnt->vm_ops->unmap(mpnt, st, end-st);
 300                 else
 301                         unmap_fixup(mpnt, st, end-st);
 302 
 303                 kfree(mpnt);
 304         }
 305 
 306         unmap_page_range(addr, len);
 307         return 0;
 308 }
 309 
 310 /* This is used for a general mmap of a disk file */
 311 int generic_mmap(struct inode * inode, struct file * file,
     /* [previous][next][first][last][top][bottom][index][help] */
 312         unsigned long addr, size_t len, int prot, unsigned long off)
 313 {
 314         struct vm_area_struct * mpnt;
 315         extern struct vm_operations_struct file_mmap;
 316         struct buffer_head * bh;
 317 
 318         if (prot & PAGE_RW)     /* only PAGE_COW or read-only supported right now */
 319                 return -EINVAL;
 320         if (off & (inode->i_sb->s_blocksize - 1))
 321                 return -EINVAL;
 322         if (!inode->i_sb || !S_ISREG(inode->i_mode))
 323                 return -EACCES;
 324         if (!inode->i_op || !inode->i_op->bmap)
 325                 return -ENOEXEC;
 326         if (!(bh = bread(inode->i_dev,bmap(inode,0),inode->i_sb->s_blocksize)))
 327                 return -EACCES;
 328         if (!IS_RDONLY(inode)) {
 329                 inode->i_atime = CURRENT_TIME;
 330                 inode->i_dirt = 1;
 331         }
 332         brelse(bh);
 333 
 334         mpnt = (struct vm_area_struct * ) kmalloc(sizeof(struct vm_area_struct), GFP_KERNEL);
 335         if (!mpnt)
 336                 return -ENOMEM;
 337 
 338         unmap_page_range(addr, len);    
 339         mpnt->vm_task = current;
 340         mpnt->vm_start = addr;
 341         mpnt->vm_end = addr + len;
 342         mpnt->vm_page_prot = prot;
 343         mpnt->vm_share = NULL;
 344         mpnt->vm_inode = inode;
 345         inode->i_count++;
 346         mpnt->vm_offset = off;
 347         mpnt->vm_ops = &file_mmap;
 348         insert_vm_struct(current, mpnt);
 349         merge_segments(current->mm->mmap, NULL, NULL);
 350         
 351         return 0;
 352 }
 353 
 354 /*
 355  * Insert vm structure into process list
 356  * This makes sure the list is sorted by start address, and
 357  * some some simple overlap checking.
 358  * JSGF
 359  */
 360 void insert_vm_struct(struct task_struct *t, struct vm_area_struct *vmp)
     /* [previous][next][first][last][top][bottom][index][help] */
 361 {
 362         struct vm_area_struct **nxtpp, *mpnt;
 363 
 364         nxtpp = &t->mm->mmap;
 365         
 366         for(mpnt = t->mm->mmap; mpnt != NULL; mpnt = mpnt->vm_next)
 367         {
 368                 if (mpnt->vm_start > vmp->vm_start)
 369                         break;
 370                 nxtpp = &mpnt->vm_next;
 371 
 372                 if ((vmp->vm_start >= mpnt->vm_start &&
 373                      vmp->vm_start < mpnt->vm_end) ||
 374                     (vmp->vm_end >= mpnt->vm_start &&
 375                      vmp->vm_end < mpnt->vm_end))
 376                         printk("insert_vm_struct: ins area %lx-%lx in area %lx-%lx\n",
 377                                vmp->vm_start, vmp->vm_end,
 378                                mpnt->vm_start, vmp->vm_end);
 379         }
 380         
 381         vmp->vm_next = mpnt;
 382 
 383         *nxtpp = vmp;
 384 }
 385 
 386 /*
 387  * Merge a list of memory segments if possible.
 388  * Redundant vm_area_structs are freed.
 389  * This assumes that the list is ordered by address.
 390  */
 391 void merge_segments(struct vm_area_struct *mpnt,
     /* [previous][next][first][last][top][bottom][index][help] */
 392                     map_mergep_fnp mergep, void *mpd)
 393 {
 394         struct vm_area_struct *prev, *next;
 395 
 396         if (mpnt == NULL)
 397                 return;
 398         
 399         for(prev = mpnt, mpnt = mpnt->vm_next;
 400             mpnt != NULL;
 401             prev = mpnt, mpnt = next)
 402         {
 403                 int mp;
 404 
 405                 next = mpnt->vm_next;
 406                 
 407                 if (mergep == NULL)
 408                 {
 409                         unsigned long psz = prev->vm_end - prev->vm_start;
 410                         mp = prev->vm_offset + psz == mpnt->vm_offset;
 411                 }
 412                 else
 413                         mp = (*mergep)(prev, mpnt, mpd);
 414 
 415                 /*
 416                  * Check they are compatible.
 417                  * and the like...
 418                  * What does the share pointer mean?
 419                  */
 420                 if (prev->vm_ops != mpnt->vm_ops ||
 421                     prev->vm_page_prot != mpnt->vm_page_prot ||
 422                     prev->vm_inode != mpnt->vm_inode ||
 423                     prev->vm_end != mpnt->vm_start ||
 424                     !mp ||
 425                     prev->vm_share != mpnt->vm_share ||         /* ?? */
 426                     prev->vm_next != mpnt)                      /* !!! */
 427                         continue;
 428 
 429                 /*
 430                  * merge prev with mpnt and set up pointers so the new
 431                  * big segment can possibly merge with the next one.
 432                  * The old unused mpnt is freed.
 433                  */
 434                 prev->vm_end = mpnt->vm_end;
 435                 prev->vm_next = mpnt->vm_next;
 436                 kfree_s(mpnt, sizeof(*mpnt));
 437                 mpnt = prev;
 438         }
 439 }
 440 
 441 /*
 442  * Map memory not associated with any file into a process
 443  * address space.  Adjecent memory is merged.
 444  */
 445 static int anon_map(struct inode *ino, struct file * file,
     /* [previous][next][first][last][top][bottom][index][help] */
 446                     unsigned long addr, size_t len, int mask,
 447                     unsigned long off)
 448 {
 449         struct vm_area_struct * mpnt;
 450 
 451         if (zeromap_page_range(addr, len, mask))
 452                 return -ENOMEM;
 453 
 454         mpnt = (struct vm_area_struct * ) kmalloc(sizeof(struct vm_area_struct), GFP_KERNEL);
 455         if (!mpnt)
 456                 return -ENOMEM;
 457 
 458         mpnt->vm_task = current;
 459         mpnt->vm_start = addr;
 460         mpnt->vm_end = addr + len;
 461         mpnt->vm_page_prot = mask;
 462         mpnt->vm_share = NULL;
 463         mpnt->vm_inode = NULL;
 464         mpnt->vm_offset = 0;
 465         mpnt->vm_ops = NULL;
 466         insert_vm_struct(current, mpnt);
 467         merge_segments(current->mm->mmap, ignoff_mergep, NULL);
 468 
 469         return 0;
 470 }
 471 
 472 /* Merge, ignoring offsets */
 473 int ignoff_mergep(const struct vm_area_struct *m1,
     /* [previous][next][first][last][top][bottom][index][help] */
 474                   const struct vm_area_struct *m2,
 475                   void *data)
 476 {
 477         if (m1->vm_inode != m2->vm_inode)       /* Just to be sure */
 478                 return 0;
 479 
 480         return (struct inode *)data == m1->vm_inode;
 481 }

/* [previous][next][first][last][top][bottom][index][help] */