--- /usr/src/linux-work/mm/mmap.c Sat Feb 26 14:31:33 2000 +++ /usr/src/linux/mm/mmap.c Sun Nov 15 19:33:20 1998 @@ -23,10 +23,6 @@ * description of effects of mapping type and prot in current implementation. * this is due to the limited x86 page protection hardware. The expected * behavior is in parens: - ** Zuordnung der protection-flags zu den mapping-Arten unter Berueck- - ** sichtigung der eingeschraenkten Moeglichkeiten des Seiten-Schutzes - ** in der x86-Architektur. In Klammern sind die eigentlich verlangten - ** Flags angegeben. * * map_type prot * PROT_NONE PROT_READ PROT_WRITE PROT_EXEC @@ -48,33 +44,17 @@ /* * Check that a process has enough memory to allocate a * new virtual mapping. - ** Das ist eher nicht so leicht zu durchschauen; es laesst sich - ** die Bedeutung der einzelnen Werte nicht so leicht ermitteln .. */ - int vm_enough_memory(long pages) { /* * stupid algorithm to decide if we have enough memory: while * simple, it hopefully works in most obvious cases.. Easy to * fool it, but this should catch most mistakes. - ** buffermem ist eine globale Variable die den aktuellen Wert - ** des z.z. zur Verfuegung stehenden Buffer-Speichers - ** (in Byte) enthaelt. - ** page_cache_size : Groesse des Seiten-Caches; wird in - ** linux/include/linux/pagemap.h manipuliert; - ** high_memory leitet sich von memory_end ab und hat etwas - ** mit der Gesamtgroesse des phys. Speichers zu tun. - ** (siehe linux/arch/i386/kernel/setup.c, linux/init/main.c, - ** mem_init()). - ** nr_free_pages wird in page_alloc.c definiert und manipuliert; - ** wo wird es wirklich initialisiert ?? - ** nr_swap_pages : mm/swapfile.c; freie Seiten im Swape-Space .. */ long freepages; freepages = buffermem >> PAGE_SHIFT; freepages += page_cache_size; - /* MAP_NR macht aus high_memory die Anzahl der Speicherseiten */ if (freepages <= (MAP_NR(high_memory) >> 4) + 48) freepages >>= 1; freepages += nr_free_pages; @@ -139,11 +119,6 @@ * Combine the mmap "prot" and "flags" argument into one "vm_flags" used * internally. Essentially, translate the "PROT_xxx" and "MAP_xxx" bits * into "VM_xxx". - ** Erzeugt ein kombiniertes prot-flags-flag vm_flag mit hilfe der inline - ** Funktion _trans() : - ** if (b1==b2) then x&b1 - ** elseif (x&b1) then b2 (x&b1==0 = true) - ** else 0 */ static inline unsigned long vm_flags(unsigned long prot, unsigned long flags) { @@ -163,318 +138,133 @@ #undef _trans } -/* do_mmap () Zentrale Kernelfunktion fuer das Einblenden von Objekten - * in den Adressraum eines Prozesses. Die eigentliche, - * objektabhaengige Arbeit wird von einer objektspezifischen - * Funktion (file->f_op->mmap()) erledigt. - * Die Pruefung der Zugriffsrechte erfolgt schon uebergeordnet - * beim Oeffnen des Objektes. - * Syro : new : Aenderungen beim Einblenden von Objekten in den Speicher : - * Grundsaetzlich wird die Moeglichkeit vorgesehen, einen beliebigen Offset - * zu akzeptieren. Dabei ist folgendes zu beachten : Die als Returnwert - * gelieferte Adresse stellt den Anfang der gewuenschten Einblendung dar; - * der verwaltungstechnische Anfang des Bereiches (vm_start) ist immer - * page-aligned und liefert die Basis des Returnwertes. - * Der Wert vm_offset wird als page-aligned Anteil des angegebenen Offsets - * festgelegt; die Differenz der beiden Werte ergibt den Betrag um den - * vm_start erhoeht werden muss um vm_rstart, also den Returnwert zu erhalten. - * Wenn das zugrundeliegende Objekt tatsaechlich das Einblenden ab dem - * angegebenen Offset erlaubt, so wird dieser Wert auch dem verwaltungs- - * technischen Anfang des VMAs entsprechen (der Anfang der ersten Seite). - * Ist dies nicht der Fall, so wird dieser Wert einen Offset in der ersten - * Seite des VMAs der dem angegebenen Offset-Wert in bezug auf die Seiten- - * groesse entspricht, darstellen. - * Der reale Anfangswert (vm_rstart) ist in der objektspezifischen mmap- - * Funktion eventuell entsprechend anzupassen. In do_mmap() wird er gleich - * dem Verwaltunganfang (vm_start) plus dem nicht-pagealigend Anteil des - * angegebenen Offsets gesetzt. - * Fuer den Anwender ergibt sich dadurch kein unterschied; er kann davon aus- - * gehen, dass die erhaltene Adresse den Anfang des eingeblendeten Bereiches - * angibt. - * Intern wird zu jedem VMA der verwaltungstechnische und der reale Anfang - * gespeichert. Bei Angabe einer Addresse zwischen vm_start und vm_rstart - * bei den diversen Funktionen (mprotect(), munmap(), ....) kann also davon - * ausgegangen werden, dass die Operation von Anfang des VMAs angewendet - * werden soll. Die selbe Vorgangseise wird am Ende des VMAs eingefuehrt. - * Die Moeglichkeit der Angabe eines beliebigen Offsets wird vor allem fuer - * die Implementierung des Pipe-mappings gebraucht. Die Verwaltung des - * exakten Endes des VMAs wird fuer die realisierung des 'konservativen' - * Verhaltens bei den diversen Operationen auf VMAs benoetigt. - * Unter koservativem Verhalten ist jenes Verhalten zu verstehen, bei dem - * die betreffende Funktion nur auf jene Teile (Seiten) angewendet wird, fuer - * die das verlangt wurde. Wenn eine Seite eines Bereiches nur zum Teil - * von der Operation betroffen waere, dann wird sie auf diese Seite garnicht - * angewendet. - */ unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long off) { struct mm_struct * mm = current->mm; struct vm_area_struct * vma; - /* Syro : new : */ - unsigned long rsoff = off & ~PAGE_MASK, - orilen = len; - int stream_flag = 0; /* FIFO-RDWR-Flag */ - /* - if (off) printk("[%d] do_mmap offset = %lu\n", current->pid,off); - if (addr) printk("[%d] do_mmap addr = %lu\n", current->pid,addr); - */ - /* Pruefung der Parameter auf Tauglichkeit ..... */ - /* Syro : new : Fuer die Angabe beliebiger Offsets muss hier eine - * Annahme fuer die tatsaechliche Laenge getroffen werden. Es wird - * davon ausgegangen, dass mmap-Basis eine Seitengrenze ist; dadurch - * muss der Laengenwert um den Offset in Bezug zur Seitengrenze - * erhoet werden. Sollte das zugrundeliegende Objekt tatsaechlich das - * Einblenden am angegebenen Offset gestatten, so muss in der objekt- - * spezifischen mmap()-Funktion eine Korrektur der vm_end-Werte durch- - * gefuehrt werden. */ - len += rsoff; - off &= PAGE_MASK; /* Syro : new : der nichtaligned Anteil ist rsoff */ - if ((len = PAGE_ALIGN(len)) == 0) /* Laenge auf ein ganzzahliges */ - return addr; /* Vielfaches der Page-Size aufgerundet. */ - - if (len > MAX_USER_ADDR || addr > MAX_USER_ADDR-len) /* akademischer */ - { - return -EINVAL; /* natur; TASK_SIZE : asm/processor.h */ - } + if ((len = PAGE_ALIGN(len)) == 0) + return addr; + + if (len > MAX_USER_ADDR || addr > MAX_USER_ADDR-len) + return -EINVAL; + /* offset overflow? */ - if (off + len < off) /* Simpler Overflow Test ... */ - { + if (off + len < off) return -EINVAL; - } - /* mlock MCL_FUTURE? - ** Sollte der angeforderte Mapping Bereich gelocked werden, so - ** wird geprueft, ob nicht die maximale Groesse des fuer den - ** Prozess lockbaren Bereich ueberschritten wird. - */ + /* mlock MCL_FUTURE? */ if (mm->def_flags & VM_LOCKED) { unsigned long locked = mm->locked_vm << PAGE_SHIFT; locked += len; if (locked > current->rlim[RLIMIT_MEMLOCK].rlim_cur) - { return -EAGAIN; - } } /* * do simple checking here so the lower-level routines won't have * to. we assume access permissions have been handled by the open * of the memory object, so we don't do any here. - ** Hier werden allgemeine Pruefungen durchgefuehrt um sie den - ** objektspezifischen (low-level) Routinen zu ersparen. - ** Die Zugriffsrechte sollten schon uebergeordnet beim Oeffnen - ** des Objektes geprueft worden sein. */ - if (file != NULL) { /* Nur bei nicht-Anonymen mapping ... */ - /* Es muss leider geprueft werden, ob es sich um eine Pipe-Inode - * handelt, da auch die Lesepipe schreibbar gemapped werden koennen - * soll (soll ja gleich als Arbeitsspeicher verwendet werden - * koennen). Bei der Schreib-Pipe gilt das auch. */ - /* Angabe von FIFO-Auspraegung */ - if (flags & MAP_RDSTREAM) { - if ((flags & MAP_WRSTREAM)||!(file->f_inode->i_pipe)) - return -EINVAL; - stream_flag = MAP_RDSTREAM; - flags = flags & ~MAP_RDSTREAM; -/* printk("[%d] Got MAP_RDSTREAM (%d)\n", current->pid, stream_flag); */ - } - if (flags & MAP_WRSTREAM) { - if ((flags & MAP_RDSTREAM)||!(file->f_inode->i_pipe)) - return -EINVAL; - stream_flag = MAP_WRSTREAM; - flags = flags & ~MAP_WRSTREAM; -/* printk("[%d] Got MAP_WRSTREAM (%d)\n", current->pid, stream_flag); */ - } - switch (flags & MAP_TYPE) { /* Nur das Typ-Flag anschauen */ + if (file != NULL) { + switch (flags & MAP_TYPE) { case MAP_SHARED: - /* Wenn das Objekt mit Schreiberlaubnis gemapped werden */ - /* soll aber nicht zum Schreiben geoeffnet wurde : Fehler */ - if (!stream_flag && (prot & PROT_WRITE) && - !(file->f_mode & 2)) - { - return -EACCES; /* 2 : schreiben */ - } + if ((prot & PROT_WRITE) && !(file->f_mode & 2)) + return -EACCES; /* * make sure there are no mandatory locks on the file. - ** es duerfen keine zwingenden file-locks bestehen,. - ** (siehe linux/include/linux/fs.h) */ if (locks_verify_locked(file->f_inode)) return -EAGAIN; - - /* cevans -- whoops another append-only file flaw */ - + /* cevans -- whoops another append-only file flaw */ if (IS_APPEND(file->f_inode) && (file->f_mode & 2)) - return -EACCES; - + return -EACCES; /* fall through */ - case MAP_PRIVATE: /* 1 : lesen */ - if (!stream_flag && !(file->f_mode & 1)) + case MAP_PRIVATE: + if (!(file->f_mode & 1)) return -EACCES; break; - default: /* Fehler : kein Map-Modus .. */ + default: return -EINVAL; } - if (flags & MAP_DENYWRITE) { /* Schreibzugriff direkt auf */ - if (file->f_inode->i_writecount > 0) /* die Datei */ - return -ETXTBSY; /* lifert -ETXTBSY */ + if (flags & MAP_DENYWRITE) { + if (file->f_inode->i_writecount > 0) + return -ETXTBSY; } - } - - else if ((flags & MAP_TYPE) != MAP_PRIVATE) /* Anonymous mapping */ - return -EINVAL; /* nur als MAP_PRIVATE ???????????? */ + } else if ((flags & MAP_TYPE) != MAP_PRIVATE) + return -EINVAL; /* * obtain the address to map to. we verify (or select) it and ensure * that it represents a valid section of the address space. - ** Erhalten der Zieladresse fuer das mapping. Sie muss ausgewaehlt/ - ** geprueft werden um sicherzustellen, dass es sich um eine gueltige - ** Adresse im Adressraum des Prozesses handelt. */ - if ((flags & MAP_FIXED)) { /* Adresse vorgegeben .... */ - if (addr & ~PAGE_MASK) - return -EINVAL; - } - else { /* passenden Adressbereich ermitteln .... */ - addr = get_unmapped_area(addr, len); /* ( in mm/mmap.c ) */ + if (flags & MAP_FIXED) { + if (addr & ~PAGE_MASK) + return -EINVAL; + } else { + addr = get_unmapped_area(addr, len); if (!addr) - return -ENOMEM; + return -ENOMEM; } /* * determine the object being mapped and call the appropriate * specific mapper. the address has already been validated, but * not unmapped, but the maps are removed from the list. - ** Pruefen ob der objekt-spezifische Mapper angegeben ist - ** (natuerlich nur im Fall eines nicht anonymen mappings). - ** Die Adresse wurde geprueft; es erfolgte aber noch kein unmap; - ** eventuelle mappings wurden aber bereits aus der vma-Liste - ** entfernt. -> do_munmap() ... - ** Gibts zugehoerige Funktionen (f_op) ? - ** insbesondere einen Mapper (f_op->mmap) ? ... - ** (siehe strucht_file S163; struct file_operations S164) */ if (file && (!file->f_op || !file->f_op->mmap)) return -ENODEV; - /* - ** Neuen Eintrag in die vma-Liste herstellen ... - */ vma = (struct vm_area_struct *)kmalloc(sizeof(struct vm_area_struct), GFP_KERNEL); if (!vma) return -ENOMEM; - /* Initialisieren des neuen vma-Eintrages */ - vma->vm_mm = mm; /* Verweis in die Task-Struktur des Prozesses .. */ + vma->vm_mm = mm; vma->vm_start = addr; vma->vm_end = addr + len; - /* Syro : new : Sollte sich aus dem Offset-Wert ein anderer - * tatsaechlicher Anfangswert ergeben, so muss dies in der objekt- - * spezifischen mmap()-Funktion in vm_rstart eingetragen werden. - * Auf alle Faelle wird der nicht pagealigned Anteil des Offsets in - * rstart eingetragen. Im Normalfall wird er gleich dem Wert vm_start - * sein. */ - vma->vm_rstart = vma->vm_start + rsoff; - vma->vm_rend = vma->vm_rstart + orilen; - /* vm_flags erzeugt aus den Einzelfags prot, flags ein gesamtes.. */ vma->vm_flags = vm_flags(prot,flags) | mm->def_flags; - - /* Die in mm.h definierten Werte fuer VM_MAY.... sind NICHT die - * eigentlichen protection-Flags. Diese stehen im LSB. Die VM_MAY... - * werden von mprotect() verwendet um festzustellen ob eine - * Zugriffsaenderung erlaubt ist. - * - * NOTE: in linux/include/linux/fs.h werden zwar Konstante fuer - * 1 und 2 definiert, aber leider nur selten verwendet. - * #define FMODE_READ 1 - * #define FMODE_WRITE 2 - - */ - - if (file) { /* 1 (lesen) -> lesen/schreiben(?)/ausfuehren */ + if (file) { if (file->f_mode & 1) vma->vm_flags |= VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC; if (flags & MAP_SHARED) { - vma->vm_flags |= VM_SHARED | VM_MAYSHARE; + vma->vm_flags |= VM_SHARED | VM_MAYSHARE; /* - ** - ** - ** - * This looks strange, but when we don't have the file - * open for writing, we can demote the shared mapping - * to a simpler private mapping. That also takes care - * of a security hole with ptrace() writing to a - * shared mapping without write permissions. - ** Nur zum Lesen geoeffnete SHARED-mappings koennen - ** wie PRIVATE-mappings behandelt werden ... - * - * We leave the VM_MAYSHARE bit on, just to get - * correct output from /proc/xxx/maps.. + * This looks strange, but when we don't have the file open + * for writing, we can demote the shared mapping to a simpler + * private mapping. That also takes care of a security hole + * with ptrace() writing to a shared mapping without write + * permissions. + * + * We leave the VM_MAYSHARE bit on, just to get correct output + * from /proc/xxx/maps.. */ - if (!(file->f_mode & 2)) /* ( !2 !!! nur lesen -> */ - /* schreiben und share werden wieder ausmaskiert ... */ + if (!(file->f_mode & 2)) vma->vm_flags &= ~(VM_MAYWRITE | VM_SHARED); } - /* Objekte die nicht zum Lesen (nicht 1) geoeffnet - * und PRIVATE gemapped wurden bekommen hier nichts ge- - * setzt bzw. geloescht. Das mag das seltsame Verhalten - * erklaeren (WRONLY geoeffnete Objekte lassen sich - * nicht mappen ...) - */ - } else /* hier ist anonymes Mapping ... */ + } else vma->vm_flags |= VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC; - - - /* pageprotection_map stellt die Abbildung zwischen den theoretisch - * vom arichitekturunabhaengigen Speichermodell vorgesehenen und - * den tatsaechlichen mapping-Arten dar. Es ist ein Array mit 16 - * Elementen. Daher auch das bitweise UND mit vma_flags fuer den - * Index. Es werden hier nur die echten Protection-Flags angegeben, - * VM_MAY... werden durch bitweises und mit 0x0f ausmaskiert. */ - vma->vm_page_prot = protection_map[vma->vm_flags & 0x0f]; - vma->vm_offset = off; - /* vma->vm_pte = 0; fuer SYS V Shared Memory und Pipe-mmap.... */ - /* Syro New : Bei der Pipe wird in der do_mmap-Funktion die Info ob - * Read- oder Write-FIFO angegeben, gebraucht. Keine andere - * Moeglichkeit zur Uebergabe. */ - vma->vm_pte = (unsigned long) stream_flag; - /* Eine ev. notwendige Initialisierung der vm_inode- und vm_ops- - * Komponente muss im objektspezifischen Mapper erfolgen ! */ vma->vm_ops = NULL; - vma->vm_inode = NULL; - - /* sollten noch mappings an der Adresse bestehen, werden sie jetzt - * entfernt. */ + vma->vm_offset = off; + vma->vm_inode = NULL; + vma->vm_pte = 0; do_munmap(addr, len); /* Clear old maps */ /* Check against address space limit. */ - /** Pruefung auf Adressraum-Ueberschreitung. total_vm ist die Groesse - ** des virtuellen Speichers in Pages; wird in linux/fs/exec.c - ** initialisiert. Der neue Wert (alt + len) darf das aktuelle Soft- - ** limit fuer die Adressraumgroesse nicht ueberschreiten (Limits in - ** linux/include/linux/resource.h). - **/ if ((mm->total_vm << PAGE_SHIFT) + len > current->rlim[RLIMIT_AS].rlim_cur) { kfree(vma); return -ENOMEM; } - /* Private writable mapping? Check memory availability.. - ** Wenn es ein private mapping mit Schreiberlaubnis ist, dann - ** muss geprueft werden, ob ueberhaupt soviel Speicher da ist. - ** (Die Abfrage schaut ob das VM_SHARED gesetzt ist - also ist - ** eigentlich umgekehrt ..) - */ + /* Private writable mapping? Check memory availability.. */ if ((vma->vm_flags & (VM_SHARED | VM_WRITE)) == VM_WRITE) { if (!vm_enough_memory(len >> PAGE_SHIFT)) { kfree(vma); @@ -482,7 +272,7 @@ } } - if (file) { /* Aufruf des objektspezifischen Mappers ... */ + if (file) { int error = file->f_op->mmap(file->f_inode, file, vma); if (error) { @@ -492,89 +282,46 @@ } flags = vma->vm_flags; - insert_vm_struct(mm, vma); /* Eintrag des neuen VMA-Elements. */ - /* Ev. koennen jetzt einzelne VMAs zu einem groesseren - * zusammengefasst werden .. */ - + insert_vm_struct(mm, vma); merge_segments(mm, vma->vm_start, vma->vm_end); - /* merge_segments might have merged our vma, so we can't - * use it any more - * ACHTUNG : merge_segments koennte unseren bisherigen Eintrag mit - * anderen zusammengefasst haben, sodass wir ihn nicht mehr ansprechen - * koennen. - */ - mm->total_vm += len >> PAGE_SHIFT; /* Der VM ist um len groesser .. */ - - /* Wenn der Bereich gesperrt werden soll, so ist das der letzte - * durchzufuehrende Schritt. Dabei werden alle Pages des neuen - * Bereiches einmal referenziert, um sicherzustellen dass sie - * tatsaechlich zugeordnet sind. */ - - if (flags & VM_LOCKED) { + /* merge_segments might have merged our vma, so we can't use it any more */ + mm->total_vm += len >> PAGE_SHIFT; + if (flags & VM_LOCKED) { unsigned long start = addr; mm->locked_vm += len >> PAGE_SHIFT; - do { /* Der Bereich wird gelocked... (??!) */ + do { char c = get_user((char *) start); len -= PAGE_SIZE; start += PAGE_SIZE; - __asm__ __volatile__("": :"r" (c)); /* ??!! */ + __asm__ __volatile__("": :"r" (c)); } while (len > 0); } - - return vma->vm_rstart; /* Syro : new : */ + return addr; } /* * Get an address range which is currently unmapped. * For mmap() without MAP_FIXED and shmat() with addr=0. * Return value 0 means ENOMEM. - ** Liefert einen ungemappten Speicherbereich. Wird von den Funktionen - ** mmap() mit MAP_FIXED und shmat() mit dem Wert addr=0 aufgerufen. Um - ** eine Adresse frei zu waehlen. - ** Return 0 bedeutet : kein Speicher ENOMEM. - ** Es erfolgt eine zweistufige Suche. Zuerst wird der AVL-Baum schon - ** belegten Speicherbereiche durchsucht (find_vma()). Da das eigentliche - ** Suchziel ja ein Zwischenraum zwischen diesen Speicherbereichen ist, - ** endet diese Suche mit dem Speicherbereich der den erst moeglichen - ** freien Bereich nach unten hin begrenzt; addr liegt also in diesem - ** von find_vma gelieferten Bereich : vm_start < addr < vm_end. - ** Die andere Moeglichkeit des Endes ist dass kein solcher Speicher- - ** Bereich gefunden wird (vmm==null). Das Bedeutet, dass die Adresse - ** schon in einem freien Bereich liegt. - ** Die naechste Suche verwendet die einfach verkettete vma-Liste. - ** Ziel ist es einen fuer len passenden Zwischenraum zu finden. - ** addr wird zunaechst auf das Ende des erhaltenen Bereiches gelegt, - ** da ja addr+len sicher nicht kleiner als vma_start sein kann, da - ** ja schon addr alleine groesser war ! Im naechsten Schritt wird - ** der naechste belegte Bereich (vmm) betrachtet. Liegt sein Anfang - ** ueber addr+len dann reicht der freie Bereich aus. Ansonsten - ** wird die Suche fortgesetzt. Spaetestens am Ende der Liste kann - ** der neue Speicherbereich in anspruch genommen werden - ausser es - ** wird dabei die TASK_SIZE ueberschritten. */ - unsigned long get_unmapped_area(unsigned long addr, unsigned long len) { struct vm_area_struct * vmm; - if (len > MAX_USER_ADDR) /* Fehler wenn d. groesse d. angeforderten */ - return 0; /* Speicher die gesamte Task-Groesse uebersteigt */ - if (!addr) /* Adresse als TASK_SIZE / 3 waehlen .. */ - addr = MMAP_SEARCH_START; - /* addr = TASK_SIZE / 3; old ... */ - addr = PAGE_ALIGN(addr); /* Adresse auf Seitengrenze legen. */ - - /* find_vma() durchsucht den AVL-Baum; (include/linux/mm.h) */ - /* die Schleife geht die lineare Liste durch; der Wert von */ - /* addr wird dabei aber veraendert ! */ + if (len > MAX_USER_ADDR) + return 0; + if (!addr) + addr = MMAP_SEARCH_START; + addr = PAGE_ALIGN(addr); + for (vmm = find_vma(current->mm, addr); ; vmm = vmm->vm_next) { /* At this point: (!vmm || addr < vmm->vm_end). */ - if (MAX_USER_ADDR - len < addr) /* kann nicht mehr passen ! */ - return 0; /* keine Adresse ... Fehler */ - if (!vmm || addr + len <= vmm->vm_start) - return addr; /* keine Ueberlappung */ - addr = vmm->vm_end; /* Anfang des naechsten freien Bereiches */ + if (MAX_USER_ADDR - len < addr) + return 0; + if (!vmm || addr + len <= vmm->vm_start) + return addr; + addr = vmm->vm_end; } } @@ -761,8 +508,6 @@ /* Insert a node into a tree, and * return the node to the left of it and the node to the right of it. - ** Fuegt einen Knoten in den AVL-Baum ein und liefert den linken - ** und rechten Nachbarn zurueck. */ static inline void avl_insert_neighbours (struct vm_area_struct * new_node, struct vm_area_struct ** ptree, struct vm_area_struct ** to_the_left, struct vm_area_struct ** to_the_right) @@ -974,15 +719,7 @@ unsigned long addr, size_t len) { struct vm_area_struct *mpnt; - unsigned long end; - /* Syro : new : */ - unsigned long raddr = addr, rend = addr + len; - - /* Syro : new : was los */ - - addr &= PAGE_MASK; - len = PAGE_ALIGN((raddr - addr) + len); - end = addr + len; + unsigned long end = addr + len; if (addr < area->vm_start || addr >= area->vm_end || end <= area->vm_start || end > area->vm_end || @@ -992,16 +729,6 @@ area->vm_start, area->vm_end, addr, end); return; } - - /* Syro : new : */ - addr = (raddr <= area->vm_rstart) ? area->vm_start :\ - ((raddr - addr) ? addr + PAGE_SIZE : addr); - end = ((rend >= area->vm_rend) ? area->vm_end : \ - ((end - rend) ? (end - PAGE_SIZE) : end)); - raddr = (raddr <= area->vm_rstart) ? area->vm_start : raddr; - rend = ((rend) >= area->vm_rend) ? area->vm_end : rend; - len = end - addr; - area->vm_mm->total_vm -= len >> PAGE_SHIFT; if (area->vm_flags & VM_LOCKED) area->vm_mm->locked_vm -= len >> PAGE_SHIFT; @@ -1009,60 +736,48 @@ /* Unmapping the whole area */ if (addr == area->vm_start && end == area->vm_end) { if (area->vm_ops && area->vm_ops->close) - area->vm_ops->close(area); + area->vm_ops->close(area); if (area->vm_inode) iput(area->vm_inode); return; } /* Work out to one of the ends */ - if (end == area->vm_end) { + if (end == area->vm_end) area->vm_end = addr; - area->vm_rend = raddr; - } else if (addr == area->vm_start) { - area->vm_offset += (end - area->vm_start); - /* Syro : new : */ + area->vm_offset += (end - area->vm_start); area->vm_start = end; - area->vm_rstart = rend; } else { /* Unmapping a hole: area->vm_start < addr <= end < area->vm_end */ /* Add end mapping -- leave beginning for below */ mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL); - if (!mpnt) { - printk("unmap_fixup : no mem for kmalloc !!\n"); + if (!mpnt) return; - } *mpnt = *area; mpnt->vm_offset += (end - area->vm_start); mpnt->vm_start = end; - mpnt->vm_rstart = rend; if (mpnt->vm_inode) mpnt->vm_inode->i_count++; if (mpnt->vm_ops && mpnt->vm_ops->open) - /* Syro : new : */ - mpnt->vm_ops->open(mpnt, VM_OC_COPY, NULL); + mpnt->vm_ops->open(mpnt); area->vm_end = addr; /* Truncate area */ - area->vm_rend = raddr; /* Truncate area */ insert_vm_struct(current->mm, mpnt); } /* construct whatever mapping is needed */ mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL); - if (!mpnt) { - printk("unmap_fixup : no mem for kmalloc !!\n"); + if (!mpnt) return; - } *mpnt = *area; if (mpnt->vm_ops && mpnt->vm_ops->open) - mpnt->vm_ops->open(mpnt, VM_OC_NOOP, NULL); /* Syro : new : */ + mpnt->vm_ops->open(mpnt); if (area->vm_ops && area->vm_ops->close) { area->vm_end = area->vm_start; - area->vm_rend = area->vm_rstart = area->vm_start; - area->vm_ops->close(area); + area->vm_ops->close(area); } insert_vm_struct(current->mm, mpnt); } @@ -1077,24 +792,12 @@ * what needs doing, and the areas themselves, which do the * work. This now handles partial unmappings. * Jeremy Fitzhardine - * Es sind beliebige Adressen und Laengen erlaubt. Die urspruenglichen - * Parameter werden gesichert und die Werte fuer die Ermittlung der - * betreffenden VMAs auf Seitengrenzen gezogen; addr nach unten und len - * um den Pageoffset in addr erhoeht nach oben. */ int do_munmap(unsigned long addr, size_t len) { struct vm_area_struct *mpnt, *prev, *next, **npp, *free; - /* Syro : new : */ - struct vm_area_struct *first; - unsigned long raddr = addr, - rlen = len; - - addr &= PAGE_MASK; - len = PAGE_ALIGN(len + (raddr & ~PAGE_MASK)); - if ((addr & ~PAGE_MASK) || addr > MAX_USER_ADDR || \ - len > MAX_USER_ADDR-addr) + if ((addr & ~PAGE_MASK) || addr > MAX_USER_ADDR || len > MAX_USER_ADDR-addr) return -EINVAL; if ((len = PAGE_ALIGN(len)) == 0) @@ -1109,29 +812,6 @@ mpnt = find_vma(current->mm, addr); if (!mpnt) return 0; - - /* Syro : new : Es wird hier schon der VMA der Endadresse gebraucht - * um die Kontrolle auf < eine Seite und Anfangs-/End-Wert zu machen. - * Ansonsten muesste mit dem AVL-Tree-Code gearbeitet werden. */ - free = find_vma(current->mm, raddr + rlen); - if (!free) - return 0; - - /* Syro : new : Wenn ein Bereich ausgeblendet werden soll, der - * innerhalb einer Speicherseite liegt, so geht das nur, wenn - * eine der Bereichsgrenzen mit einer des VMAs zusamenfaellt. - */ - if ((((raddr & ~PAGE_MASK) + rlen) < PAGE_SIZE) && - (raddr > mpnt->vm_rstart) && (raddr+rlen < free->vm_rend)) { - printk("[%d] unmap : invalid area start %lx len %lx\n", - current->pid,raddr,rlen); - return -EINVAL; - } - /* Syro : new : first wird der Letzte in der free-Liste sein. - * Sollte die Liste nur ein Element haben, muss genauer geprueft - * werden. */ - - first = mpnt; avl_neighbours(mpnt, current->mm->mmap_avl, &prev, &next); /* we have prev->vm_next == mpnt && mpnt->vm_next = next */ /* and addr < mpnt->vm_end */ @@ -1153,64 +833,23 @@ * so release them, and unmap the page range.. * If the one of the segments is only being partially unmapped, * it will put new vm_area_struct(s) into the address space. - * Es werden zuerst einmal alle ausgewaehlten Areas (free) entfernt. - * Sollte von einem Bereich nur ein Teil entfernt werden, so wird - * danach eine neuer VMA wieder angelegt. */ - do { unsigned long st, end; - /* Syro : new : Die Werte fuer die tatsaechlichen Bereichs- - * grenzen. */ - unsigned long rst, rend; mpnt = free; free = free->vm_next; remove_shared_vm_struct(mpnt); - /* Wenn die reale Adresse kleiner ist als der VMA-Start, kann - * dieser vom Anfang an ausgeblendet werden. Ansonsten handelt - * es sich um den Anfangsbereich. Hier muss der reale Anfang - * beruecksichtigt werden. Ist die Adresse kleiner oder gleich - * diesem, kann von Anfang weg ausgeblendet werden. Ansonst - * muss das konservative Verhalten gezeigt werden. Die Seite - * in der die Adresse liegt darf nicht ausgeblendet werden. - * Daher die Trennung in rst und st. */ - st = (raddr <= mpnt->vm_rstart) ? mpnt->vm_start :\ - ((raddr - addr) ? addr + PAGE_SIZE : addr); - /* Am anderen Bereichsende gilt das selbe : die Seite in der - * das Ende des auszublendenden Bereiches liegt darf nicht - * ausgeblendet werden. */ - end = ((raddr + rlen) >= mpnt->vm_rend) ? \ - mpnt->vm_end : (((addr+len)-(raddr+rlen)) ?\ - (addr + len - PAGE_SIZE) : (addr + len)); - rst = (raddr <= mpnt->vm_rstart) ? mpnt->vm_start : raddr; - rend = ((raddr + rlen) >= mpnt->vm_rend) ? mpnt->vm_end :\ - (raddr+rlen); - - /* Dieser Fall sollte nie auftreten ! */ - if (end < st) { - printk("munmap : error : end < st (%lx <= %lx)\n", - end,st); - printk("addr0x%lx, len0x%lx, raddr0x%lx, rlen0x%lx\n", - addr,(unsigned long)len,raddr,rlen); - return -EINVAL; - } + st = addr < mpnt->vm_start ? mpnt->vm_start : addr; + end = addr+len; + end = end > mpnt->vm_end ? mpnt->vm_end : end; - /* Aufruf der unmap()-Funktion muss mit den realen Bereichs- - * Werten erfolgen ! Ist weiter kein Problem, da es z.Z. nur - * zwei solcher Funktionen gibt : fuer das allgemeine File- - * mmap in mm/filemap.c; wird sofort auf ein sync weiter- - * geleitet, in dem die Adress-Auswertung nocheinmal enthalten - * ist. Und in fs/pipe.c; hier muessen auf alle Faelle die - * echten Offset-Werte verfuegbar sein. - * ==>> rst und rend-rst */ if (mpnt->vm_ops && mpnt->vm_ops->unmap) - mpnt->vm_ops->unmap(mpnt, rst, rend-rst, - current); /* Syro : new : task */ + mpnt->vm_ops->unmap(mpnt, st, end-st); zap_page_range(current->mm, st, end-st); - unmap_fixup(mpnt, rst, rend-rst); + unmap_fixup(mpnt, st, end-st); kfree(mpnt); } while (free); @@ -1230,34 +869,10 @@ } /* Release all mmaps. */ -/* Syro : new : Da exit_mmap() auch von fork() aus fuer VMAs des child- - * prozesses aufgerufen werden kann, muss der Task zugaenglich sein. - * Daher wird der Wert task_struct *tsk der Parameterliste angefuegt. - */ - -void exit_mmap(struct mm_struct *mm, struct task_struct *tsk) -/* void exit_mmap(struct mm_struct * mm) */ +void exit_mmap(struct mm_struct * mm) { struct vm_area_struct * mpnt; - if (tsk == NULL){ - printk("[%d]NULL tsk to exit_mmap ..\n",current->pid); - return; - } - else { - if (tsk->mm == NULL){ - printk("[%d]NULL tsk->mm to exit_mmap ..\n",current->pid); - return; - } - else { - if (tsk->mm->mmap == NULL) { - printk("[%d]NULL tsk->mm->mmap to exit_mmap ..\n", - current->pid); - return; - } - } - } - mpnt = mm->mmap; mm->mmap = NULL; mm->mmap_avl = NULL; @@ -1268,11 +883,9 @@ struct vm_area_struct * next = mpnt->vm_next; if (mpnt->vm_ops) { if (mpnt->vm_ops->unmap) - mpnt->vm_ops->unmap(mpnt, mpnt->vm_start, - mpnt->vm_end-mpnt->vm_start, - tsk); /* Syro : new : */ + mpnt->vm_ops->unmap(mpnt, mpnt->vm_start, mpnt->vm_end-mpnt->vm_start); if (mpnt->vm_ops->close) - mpnt->vm_ops->close(mpnt); + mpnt->vm_ops->close(mpnt); } remove_shared_vm_struct(mpnt); zap_page_range(mm, mpnt->vm_start, mpnt->vm_end-mpnt->vm_start); @@ -1281,18 +894,12 @@ kfree(mpnt); mpnt = next; } - return; } /* * Insert vm structure into process list sorted by address * and into the inode's i_mmap ring. - ** Fuegt eine vm-Struktur in die VMA-Liste des Prozesses und in die - ** Ringliste des zugehoerigen Inodes ein. Die Eintragung in die - ** Prozess-VMA-Liste erfolgt in den AVL-Baum als auch in die einfach - ** verkettete Liste. */ - void insert_vm_struct(struct mm_struct *mm, struct vm_area_struct *vmp) { struct vm_area_struct *share; @@ -1314,11 +921,9 @@ #else struct vm_area_struct * prev, * next; - /* Eintragung in den AVL-Baum. */ avl_insert_neighbours(vmp, &mm->mmap_avl, &prev, &next); if ((prev ? prev->vm_next : mm->mmap) != next) printk("insert_vm_struct: tree inconsistent with list\n"); - /* Eintragung in die einfach verkettete Liste. */ if (prev) prev->vm_next = vmp; else @@ -1327,7 +932,7 @@ #endif inode = vmp->vm_inode; - if (!inode) /* Wohl bei anonymen Mapping ... */ + if (!inode) return; /* insert vmp into inode's circular share list */ @@ -1370,27 +975,20 @@ * This assumes that the list is ordered by address. * We don't need to traverse the entire list, only those segments * which intersect or are adjacent to a given interval. - ** Zusammenfassen der VMA-Liste wenn moeglich; ueberfluessige Eintraege - ** werden freigegeben. Die Liste muss schon nach den Adressen sortiert - ** sein. Es muss nicht die ganze Liste betrachtet werden, sondern nur die - ** Eintraege die in ein gegenbenes Intervall fallen ... - ** start_addr und end_addr sind der Anfang und das Ende des neuen VMAs ... - ** Diese Funktion wird auch nur hier von do_mmap() aufgerufen ! */ void merge_segments (struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr) { struct vm_area_struct *prev, *mpnt, *next; - down(&mm->mmap_sem); /* Semaphore loeschen, Liste sperren.. */ - mpnt = find_vma(mm, start_addr); - if (!mpnt) /** Multitasking & Unterbrechungen .. wer weiss, man hat - ** u.U. geschlafen und der vma ist geloescht worden ... */ + down(&mm->mmap_sem); + mpnt = find_vma(mm, start_addr); + if (!mpnt) goto no_vma; avl_neighbours(mpnt, mm->mmap_avl, &prev, &next); /* we have prev->vm_next == mpnt && mpnt->vm_next = next */ - if (!prev) { /* kein Vorgaenger : Merge-Eintrag ist erster .. */ + if (!prev) { prev = mpnt; mpnt = next; } @@ -1399,12 +997,14 @@ * start_addr < mpnt->vm_end && prev->vm_start < end_addr */ for ( ; mpnt && prev->vm_start < end_addr ; prev = mpnt, mpnt = next) { +#if 0 + printk("looping in merge_segments, mpnt=0x%lX\n", (unsigned long) mpnt); +#endif next = mpnt->vm_next; /* * To share, we must have the same inode, operations.. - ** Zum Zusammenlegen muss natuerlich alles gleich sein !! */ if (mpnt->vm_inode != prev->vm_inode) continue; @@ -1416,18 +1016,6 @@ continue; if (prev->vm_end != mpnt->vm_start) continue; - /* Syro : new - wenn es der VMA einer Pipe ist, dann soll er - * auf keinen Fall mit anderen zusammengelegt werden. Man - * sollte die vm_operations um eine merge()-Komponente - * erweitern, um hier individuell handeln zu koennen. Das ist - * aber ein groesserer Eingriff. Vorerst wird nur auf eine - * Pipe-Inode geprueft ... */ - if (mpnt->vm_inode != NULL && ((mpnt->vm_inode)->i_pipe ||\ - (prev->vm_inode)->i_pipe)) { - /* Inodes sind hier sicher schon gleich ... */ - printk("VMA-merge : can't merge pipe-vma ..\n"); - continue; - } /* * and if we have an inode, the offsets must be contiguous.. */ @@ -1435,35 +1023,18 @@ if (prev->vm_offset + prev->vm_end - prev->vm_start != mpnt->vm_offset) continue; } - /* Syro : new : Wenn zwischen echtem Ende des einen und echtem - * Anfang des andren VMAs ein Loch ist, darf auf keinen Fall - * gemerged werden. */ - if (prev->vm_end != prev->vm_rend) - continue; - if (mpnt->vm_start != mpnt->vm_rstart) - continue; + /* * merge prev with mpnt and set up pointers so the new * big segment can possibly merge with the next one. * The old unused mpnt is freed. - ** Zusammenfassen von zwei VMAs zu einem grossen; Alle - ** Zeiger entsprechend setzen um ev. auch gleich mit dem - ** naechsten zusammenfassen zu koennen. */ avl_remove(mpnt, &mm->mmap_avl); prev->vm_end = mpnt->vm_end; - /* Syro : new : */ - prev->vm_rend = mpnt->vm_rend; prev->vm_next = mpnt->vm_next; if (mpnt->vm_ops && mpnt->vm_ops->close) { - /* Da der Bereich mpnt ja nicht ausgeblendet wird, sondern - * mit einem anderen zusammengelegt wird, wird die close- - * Komponente mit einem Bereich der Laenge 0 aufgerufen */ mpnt->vm_offset += mpnt->vm_end - mpnt->vm_start; mpnt->vm_start = mpnt->vm_end; - /* Syro : new : Es werden nie Pipe-Mappings - * zusammengefasst; daher kann es auch nicht notwendig - * sein Mapper-Entrys zusammenzufassen. */ mpnt->vm_ops->close(mpnt); } remove_shared_vm_struct(mpnt); @@ -1473,20 +1044,5 @@ mpnt = prev; } no_vma: - up(&mm->mmap_sem); /* Liste wieder Freigeben .. */ + up(&mm->mmap_sem); } - - - - - - - - - - - - - - - --- /usr/src/linux-work/mm/mremap.c Tue Oct 19 22:31:51 1999 +++ /usr/src/linux/mm/mremap.c Thu Jun 4 00:17:50 1998 @@ -31,7 +31,7 @@ if (pgd_none(*pgd)) goto end; if (pgd_bad(*pgd)) { - printk("get_one_pte: bad source pgd (%08lx)\n", pgd_val(*pgd)); + printk("move_one_page: bad source pgd (%08lx)\n", pgd_val(*pgd)); pgd_clear(pgd); goto end; } @@ -40,7 +40,7 @@ if (pmd_none(*pmd)) goto end; if (pmd_bad(*pmd)) { - printk("get_one_pte: bad source pmd (%08lx)\n", pmd_val(*pmd)); + printk("move_one_page: bad source pmd (%08lx)\n", pmd_val(*pmd)); pmd_clear(pmd); goto end; } @@ -62,9 +62,8 @@ pte = pte_alloc(pmd, addr); return pte; } -/* Syro : new : copy_one_pte in move_one_pte umbenannt. */ -static inline int move_one_pte(pte_t * src, pte_t * dst) +static inline int copy_one_pte(pte_t * src, pte_t * dst) { int error = 0; pte_t pte = *src; @@ -87,7 +86,7 @@ src = get_one_pte(mm, old_addr); if (src) - error = move_one_pte(src, alloc_one_pte(mm, new_addr)); + error = copy_one_pte(src, alloc_one_pte(mm, new_addr)); return error; } @@ -96,7 +95,6 @@ { unsigned long offset = len; - flush_cache_range(mm, old_addr, old_addr + len); flush_tlb_range(mm, old_addr, old_addr + len); @@ -128,150 +126,31 @@ return -1; } - -/* Syro : new : rm_one_page(); Loescht den angegebenen Page-Table-Entry mit - * Hilfe der Funktion pte_clear(). */ - -static void rm_one_page(struct mm_struct * mm, unsigned long addr) -{ - pte_t * pte; - - pte = get_one_pte(mm, addr); - if (pte_none(*pte)) return; - pte_clear(pte); - return; -} - -/* cpy_one_page : Es wird der angegebene PTE kopiert. Die Speicherseite - * selbst braucht nicht kopiert zu werden. (War vorher ein - * Bloedsinn !!!) - * (cpy deshalb, weil es in mm/memory.c noch ein - * copy_one_pte() gibt !!). - */ - -static inline int cpy_one_pte(pte_t * src, pte_t * dst) -{ - int error = 0; - pte_t pte = *src; - - if (!pte_none(pte)) { - error++; - if (dst) { - set_pte(dst, pte); - error--; - } - } - return error; -} - -/* Syro : new : Diese Funktion kopiert die Seite die durch old_addr - * identifiziert wird an die durch new_addr angegebene Stelle der Page-Table - * (indem der PTE kopiert wird). */ - -static int copy_one_page(struct mm_struct * mm, - unsigned long new_addr, unsigned long old_addr) -{ - - int error = 0; - pte_t * src; - - /* What the fuck is this ??!!! */ - flush_cache_range(mm, old_addr, PAGE_SIZE); - flush_tlb_range(mm, old_addr, PAGE_SIZE); - - src = get_one_pte(mm, old_addr); - if (src) - error = cpy_one_pte(src, alloc_one_pte(mm, new_addr)); - return error; -} - - -/* Syro : new : Funktion massiv umgebaut, da jetzt auf die Notwendigkeit - * eines Kopierens der ersten bzw. letzten Seite des Bereiches geprueft - * werden muss. Fuer diesen Kopiervorgang wird eine eigene neue Funktion - * implementiert. */ - static inline unsigned long move_vma(struct vm_area_struct * vma, unsigned long addr, unsigned long old_len, unsigned long new_len) { struct vm_area_struct * new_vma; - /* Syro : new : neue Variablen und deren Initialisierung. */ - unsigned long al_addr, al_nlen; - char cfp = 0, /* Flag : copy first page */ - clp = 0; /* Flag : copy last page */ - - al_addr = addr & PAGE_MASK; - al_nlen = PAGE_ALIGN((addr & ~PAGE_MASK) + new_len); - - /* Wenn der Bereichsanfang ein beliebiger Offset und nicht der - * tatsaechliche VMA-Anfang ist, dann muss der PTE der ersten Seite - * kopiert werden (da sie in beiden Bereichen liegt). */ - if ((addr != al_addr) && (addr > vma->vm_rstart)) cfp++; - - /* Ist das Bereichsende nicht page-aligned und ist es auch nicht - * das reale VMA-Ende, so muss der PTE der letzten Seite kopiert - * werden. Wenn der zu remappende Bereich aber nur in einer Seite - * liegt, dann darf diese Seite nur einmal behandelt werden. */ - if (((addr + old_len) & ~PAGE_MASK) && - ((addr + old_len) < vma->vm_rend) && - (al_addr + PAGE_SIZE < addr + old_len)) clp++; - + new_vma = (struct vm_area_struct *) kmalloc(sizeof(struct vm_area_struct), GFP_KERNEL); if (new_vma) { - unsigned long new_addr = get_unmapped_area(al_addr, al_nlen); - unsigned long mfrom, mto, mlen; - /* Syro : new : Das if in meherere Teile aufgeteilt; - * das goto-Konstrukt um die Fehlerfaelle besser behandeln zu - * koennen. */ - if (!new_addr) goto no_success; - mfrom = al_addr; - mto = new_addr; - mlen = al_nlen; - if (cfp) { - mfrom += PAGE_SIZE; - mto += PAGE_SIZE; - mlen -= PAGE_SIZE; - /* Hier wird nur die Speicherseite kopiert; die - * Eintragung der neuen Werte in den VMAs erfolg - * erst spaeter, da dann im Fehlerfall nichts - * rueckgaengig gemacht werden braucht. */ - if (copy_one_page(current->mm, new_addr, - al_addr)) goto no_success; - } - if (clp) mlen -= PAGE_SIZE; + unsigned long new_addr = get_unmapped_area(addr, new_len); - if (move_page_tables(current->mm, mto, mfrom, mlen)) - goto rm_first_page; - if (clp) - if (copy_one_page(current->mm, mto + mlen, - mfrom + mlen)) goto rm_first_page; - - *new_vma = *vma; - new_vma->vm_start = new_addr; - /* Syro : new : */ - new_vma->vm_rstart = new_addr + (addr & ~PAGE_MASK); - /* Syro : new : new_len durch al_nlen ersetzt */ - new_vma->vm_end = new_addr+al_nlen; - /* Syro : new : */ - new_vma->vm_rend = new_vma->vm_rstart+new_len; - new_vma->vm_offset = vma->vm_offset + (addr - vma->vm_start); - if (new_vma->vm_inode) - new_vma->vm_inode->i_count++; - if (new_vma->vm_ops && new_vma->vm_ops->open) - /* Syro : new : */ - new_vma->vm_ops->open(new_vma, VM_OC_COPY, NULL); - insert_vm_struct(current->mm, new_vma); - merge_segments(current->mm, new_vma->vm_start, new_vma->vm_end); - do_munmap(addr, old_len); - /* Syro : new : new_len durch al_nlen ersetzt */ - current->mm->total_vm += al_nlen >> PAGE_SHIFT; - /* Syro : new : new_vma->vm_rstart statt new_addr */ - return new_vma->vm_rstart; - - rm_first_page: - if (cfp) rm_one_page(current->mm, new_addr); - no_success: + if (new_addr && !move_page_tables(current->mm, new_addr, addr, old_len)) { + *new_vma = *vma; + new_vma->vm_start = new_addr; + new_vma->vm_end = new_addr+new_len; + new_vma->vm_offset = vma->vm_offset + (addr - vma->vm_start); + if (new_vma->vm_inode) + new_vma->vm_inode->i_count++; + if (new_vma->vm_ops && new_vma->vm_ops->open) + new_vma->vm_ops->open(new_vma); + insert_vm_struct(current->mm, new_vma); + merge_segments(current->mm, new_vma->vm_start, new_vma->vm_end); + do_munmap(addr, old_len); + current->mm->total_vm += new_len >> PAGE_SHIFT; + return new_addr; + } kfree(new_vma); } return -ENOMEM; @@ -280,46 +159,21 @@ /* * Expand (or shrink) an existing mapping, potentially moving it at the * same time (controlled by the MREMAP_MAYMOVE flag and available VM space) - * mremap() ist eine Funktion die im OG-UNIX98 Standard nicht enthalten ist. - * Sie ist auch auf anderen Systemen nicht zu finden. Genaugenommen ist diese - * Funktion auch nicht wirklich notwendig, da sie durch eine Kombination von - * anderen Funktionen ersetzt werden kann. Lediglich in dem Fall, wo eine - * Einblendung erweitert werden soll (zb nachdem eine Datei mit ftrunc() - * vergroessert wurde), vereinfacht diese Funktion die Durchfuehrung deutlich. - * Eine Verkleinerung eines Mappings wird auch hier tatsaechlich durch - * einen entsprechenden unmap-Aufruf realisiert. - * Aenderungen sind hier auf alle Faelle fuer die Erweiterung der - * VMA-Darstellung noetig. - * Das veraenderte VMA-Verwaltungsverhalten wird zum Teil durch die - * direkte Verwendung der do_unmap()-Funktion berueksichtigt. - * Alle Faelle in denen new_len < old_len ist, werden direkt auf einen - * munmap()-Aufruf umgesetzt. Alle anderen Faelle sind in gewisser Weise - * eine Vergroesserung des VMAs und sind nicht so einfach zu behandeln. - * Lediglich wenn old_len dem Ende des VMAs entspricht und noch genuegend - * freier Adressraum hinter dem VMA zur Verfuegung steht braucht keine - * Verschiebung des VMAs durchgefuehrt werden. - * Achtung : ein Aenderung der MAP-Flags wird beim mremap() nicht vorgenommen. */ asmlinkage unsigned long sys_mremap(unsigned long addr, unsigned long old_len, unsigned long new_len, unsigned long flags) { struct vm_area_struct *vma; - unsigned long olen, /* Syro : new : Page-aligned old len */ - lgrow; /* Syro : new : Zuwachs ... */ - - /* if (addr & ~PAGE_MASK) Syro : new : entfernt ... - return -EINVAL; */ - /* old_len = PAGE_ALIGN(old_len); Syro : new : verschoben ... - new_len = PAGE_ALIGN(new_len); */ + if (addr & ~PAGE_MASK) + return -EINVAL; + old_len = PAGE_ALIGN(old_len); + new_len = PAGE_ALIGN(new_len); /* * Always allow a shrinking remap: that just unmaps * the unnecessary pages.. - * Die Parameter werden direkt an den do_munmap()-Aufruf weitergegeben, - * da sie in dieser Funktion sowieso entsprechend den VMA Aenderungen - * untersucht werden (vm_rstart/vm_rend). */ if (old_len >= new_len) { do_munmap(addr+new_len, old_len - new_len); @@ -329,61 +183,37 @@ /* * Ok, we need to grow.. */ - olen = PAGE_ALIGN(old_len); - lgrow = PAGE_ALIGN(new_len - olen); - /* new_len = PAGE_ALIGN(new_len); Syro : new : brauch ma net ... */ - vma = find_vma(current->mm, addr); - - if (!vma) + if (!vma || vma->vm_start > addr) return -EFAULT; - - - if (vma->vm_start > vma->vm_rstart) - vma->vm_rstart = vma->vm_start; - if (vma->vm_end > vma->vm_rend) - vma->vm_rend = vma->vm_end; - - /* Syro : new : es wird auf vm_rstart nicht auf vm_start geprueft. */ - if (vma->vm_rstart > addr) - return -EFAULT; - /* We can't remap across vm area boundaries */ - /* Syro : new : vm_end durch vm_rend ersetzt. */ - if (old_len > vma->vm_rend - addr) + if (old_len > vma->vm_end - addr) return -EFAULT; - if (vma->vm_flags & VM_LOCKED) { unsigned long locked = current->mm->locked_vm << PAGE_SHIFT; - locked += lgrow; /* Syro : new : lgrow statt Differenz */ + locked += new_len - old_len; if (locked > current->rlim[RLIMIT_MEMLOCK].rlim_cur) return -EAGAIN; } - if ((current->mm->total_vm << PAGE_SHIFT) + lgrow /* Syro : new : */ + if ((current->mm->total_vm << PAGE_SHIFT) + (new_len - old_len) > current->rlim[RLIMIT_AS].rlim_cur) return -ENOMEM; /* Private writable mapping? Check memory availability.. */ if ((vma->vm_flags & (VM_SHARED | VM_WRITE)) == VM_WRITE) { - if (!vm_enough_memory(lgrow >> PAGE_SHIFT)) /* Syro : new : */ + if (!vm_enough_memory((new_len - old_len) >> PAGE_SHIFT)) return -ENOMEM; } /* old_len exactly to the end of the area.. */ - /* Syro : new : vm_rend statt vm_end */ - if (old_len == vma->vm_rend - addr && + if (old_len == vma->vm_end - addr && (old_len != new_len || !(flags & MREMAP_MAYMOVE))) { unsigned long max_addr = MAX_USER_ADDR; if (vma->vm_next) max_addr = vma->vm_next->vm_start; /* can we just expand the current mapping? */ if (max_addr - addr >= new_len) { - /* Syro : new : lgrow statt (new_len - old_len) */ - int pages = (lgrow) >> PAGE_SHIFT; - /* Syro : new : vm_rend statt vm_end */ - vma->vm_rend = addr + new_len; - /* Syro : new : vm_end Assignement */ -/* check against lgrow-value !! */ - vma->vm_end = PAGE_ALIGN(vma->vm_rend); + int pages = (new_len - old_len) >> PAGE_SHIFT; + vma->vm_end = addr + new_len; current->mm->total_vm += pages; if (vma->vm_flags & VM_LOCKED) current->mm->locked_vm += pages; @@ -399,9 +229,3 @@ return move_vma(vma, addr, old_len, new_len); return -ENOMEM; } - - - - - - --- /usr/src/linux-work/mm/filemap.c Tue Aug 3 13:29:24 1999 +++ /usr/src/linux/mm/filemap.c Thu Jun 4 00:17:50 1998 @@ -1097,45 +1097,18 @@ return error; } -static int filemap_sync(struct vm_area_struct * vma, unsigned long start, +static int filemap_sync(struct vm_area_struct * vma, unsigned long address, size_t size, unsigned int flags) { pgd_t * dir; - unsigned long end = start + size; + unsigned long end = address + size; int error = 0; - /* Syro : new : Um bei den eingeblendeten Pipes die Angabe von - * beliebigen Offsets zu ermoeglichen, muss die Korrektur der - * Offsets aus sys_msync() hierher verlegt werden. - * Die Wertepruefung wird an das konservative Verhalten angepasst. - * Diese Funktion wird immer aus Schleifen ueber der VMA-Liste - * aufgerufen und betrifft immer nur einen VMA. - */ - - - if ( start & ~PAGE_MASK ) { - if (start > vma->vm_rstart) - start = PAGE_ALIGN(start); - else - start = vma->vm_start; - } - if ( end & ~PAGE_MASK ) { - if (end < vma->vm_rend) - end &= PAGE_MASK; - else - end = vma->vm_end; - } - -printk("(%d) filemap_sync : %lx - %lx\n", current->pid, start, end); - if (start >= end) - return error; /* Syro : new : kann veraendert sein. */ - size = end - start; /* Syro : new : size wird ebenfalls korrigiert. */ - - dir = pgd_offset(vma->vm_mm, start); - flush_cache_range(vma->vm_mm, start, end); - while (start < end) { - error |= filemap_sync_pmd_range(dir, start, end - start, vma, flags); - start = (start + PGDIR_SIZE) & PGDIR_MASK; + dir = pgd_offset(vma->vm_mm, address); + flush_cache_range(vma->vm_mm, end - size, end); + while (address < end) { + error |= filemap_sync_pmd_range(dir, address, end - address, vma, flags); + address = (address + PGDIR_SIZE) & PGDIR_MASK; dir++; } flush_tlb_range(vma->vm_mm, end - size, end); @@ -1145,25 +1118,15 @@ /* * This handles (potentially partial) area unmaps.. */ -/* - * Syro : new : wegen fork wird auch der Task als Parameter benoetigt; hier - * ist er aber bedeutungslos. - */ -static void filemap_unmap(struct vm_area_struct *vma, unsigned long start, size_t len, struct task_struct * tsk) +static void filemap_unmap(struct vm_area_struct *vma, unsigned long start, size_t len) { filemap_sync(vma, start, len, MS_ASYNC); } /* - ** Folgende Initialisierungen ordnen den unterschiedlichen Mapping- - ** Arten entsprechende Operationen auf den Virtuellen Speicherbereichen - ** zu. Diese Werte werden von der Funktion generic_file_mmap() verwendet. - ** * Shared mappings need to be able to do the right thing at * close/unmap/sync. They will also use the private file as * backing-store for swapping.. - ** Fuer Shared Mappings muessen fuer die Ereignisse unmap, sync,swapin, - ** swapout und nopage Aktionen definiert werden. */ static struct vm_operations_struct file_shared_mmap = { NULL, /* no special open */ @@ -1180,11 +1143,9 @@ /* * Private mappings just need to be able to load in the map. - ** Private mappings muessen lediglich eingelese werden. + * * (This is actually used for shared mappings as well, if we * know they can't ever get write permissions..) - ** Fuer shared mappings, von denen klar ist, dass sie nie - ** beschreibbar werden, gilt das selbe ... */ static struct vm_operations_struct file_private_mmap = { NULL, /* open */ @@ -1200,51 +1161,23 @@ }; /* This is used for a general mmap of a disk file */ -/* Allgemeine Funktion fuer des mappen eines disk-files ... - * Hier werden im Prinzip nur einige Initalisierungen durchgefuehrt; - * Die eigentlichen Arbeiten erfolgen anscheinend erst wenn wirklich - * auf die Bereiche zugegriffen wird und dadurch exceptions ausgeloest - * werden. */ - int generic_file_mmap(struct inode * inode, struct file * file, struct vm_area_struct * vma) { struct vm_operations_struct * ops; if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) { ops = &file_shared_mmap; - /** Erweiterte Operationen nur fuer eventuell schreibbare - ** Shared Mappings ..... */ /* share_page() can only guarantee proper page sharing if - * the offsets are all page aligned. - * es gibt aber weit und breit kein share_page() ... */ - if (vma->vm_offset & (PAGE_SIZE - 1)) /* page aligend ? */ + * the offsets are all page aligned. */ + if (vma->vm_offset & (PAGE_SIZE - 1)) return -EINVAL; } else { - /* Syro : new : Laengenkorrektur sollte bei MAP_PRIVATE ein - * Buffer-Size Offset angegeben worden sein. (ohne darauf - * abzufragen). */ - unsigned long len = vma->vm_rend - vma->vm_rstart; - len = PAGE_ALIGN(len); - vma->vm_end = vma->vm_start + len; - ops = &file_private_mmap; - /* Das Mapping kann nur auf eine Block-Grenze des Objekts - * (Device, ...) erfolgen. - * Achtung : hier wird auf die i_sb-komponente zugegriffen - * ohne dass sie geprueft wurde. Im naechsten if erfolgt - * eine solche ... */ if (vma->vm_offset & (inode->i_sb->s_blocksize - 1)) return -EINVAL; } - /* i_mode beschreibt die Art und die Zugriffsrechte des Objekts; - * was aber SREG ist ???? ... */ if (!inode->i_sb || !S_ISREG(inode->i_mode)) return -EACCES; - /* Ueber die Inode_op-Komponenete readpage (wie auch writepage) - * ist im Kernel-Buch nichts zu lesen. Auf alle faelle wird ihr - * Vorhandensein hier uebreprueft. Initialisiert wurde sie mit - * generic_readpage() (fs/buffer.c); die Initialisierung ist aber - * Dateisystem-abhaengig; fuer ext2: fs/ext2/file.c ... */ if (!inode->i_op || !inode->i_op->readpage) return -ENOEXEC; UPDATE_ATIME(inode) @@ -1274,29 +1207,16 @@ return 0; } -/* Da der msync()-Aufruf bei der eingeblendeten Pipe die Rolle des - * commit() uebernehmen soll, ist hier die Weitergabe der tatsaechlichen - * Werte fuer start und len von zentraler Bedeutung. - */ - asmlinkage int sys_msync(unsigned long start, size_t len, int flags) { unsigned long end; struct vm_area_struct * vma; int unmapped_error, error; - /* Syro : new : Um den msync-call als commit bei der eingeblendeten - * Pipe verwenden zu koennen, muss die Moeglichkeit der Angabe von - * beliebigen Offsets als Adresswerte ermoeglicht werden. - * Daher werden die Align- und Test-Operationen in die aufzurufenden - * Funktionen verlegt. */ - - /* if (start & ~PAGE_MASK) + if (start & ~PAGE_MASK) return -EINVAL; - len = (len + ~PAGE_MASK) & PAGE_MASK; */ - + len = (len + ~PAGE_MASK) & PAGE_MASK; end = start + len; - if (end < start) return -EINVAL; if (flags & ~(MS_ASYNC | MS_INVALIDATE | MS_SYNC)) @@ -1314,9 +1234,9 @@ if (!vma) return -EFAULT; /* Here start < vma->vm_end. */ - if (start < vma->vm_rstart) { /* Syro : new : jetzt rstart */ + if (start < vma->vm_start) { unmapped_error = -EFAULT; - start = vma->vm_rstart; + start = vma->vm_start; } /* Here vma->vm_start <= start < vma->vm_end. */ if (end <= vma->vm_end) { @@ -1331,7 +1251,7 @@ error = msync_interval(vma, start, vma->vm_end, flags); if (error) return error; - start = vma->vm_rend; /* Syro : new : jetzt rend */ - vma = vma->vm_next; + start = vma->vm_end; + vma = vma->vm_next; } } --- /usr/src/linux-work/mm/page_alloc.c Wed Feb 10 21:18:06 1999 +++ /usr/src/linux/mm/page_alloc.c Mon Jul 13 22:47:40 1998 @@ -93,8 +93,6 @@ * Buddy system. Hairy. You really aren't expected to understand this * * Hint: -mask = 1+~mask - ** In dieser Funktion wird der Wert f"ur nr_free_pages erh"oht !! - ** ist irgendwie recht trickreich mit mask realisiert. */ static inline void free_pages_ok(unsigned long map_nr, unsigned long order) { --- /usr/src/linux-work/mm/memory.c Sat Feb 26 14:07:58 2000 +++ /usr/src/linux/mm/memory.c Wed Sep 11 16:57:19 1996 @@ -297,10 +297,8 @@ flush_tlb_range(dst, vma->vm_start, vma->vm_end); return error; } -/* Syro : new : static inline weg, - * da die Funktion auch ausserhalb gebraucht wird */ -void free_pte(pte_t page) +static inline void free_pte(pte_t page) { if (pte_present(page)) { unsigned long addr = pte_page(page); @@ -606,13 +604,7 @@ pte_t *page_table, pte; unsigned long old_page, new_page; - /* Neue Page anfordern ... */ new_page = __get_free_page(GFP_KERNEL); - /* Ermitteln des richtigen Page-Table Eintrages; - * Label end_wp_page bedeutet, dass nichts gemacht wird; kein Fehler. - * alle anderen Labels werden in Fehlerfaellen angesprungen; dabei - * wird in jedem Fall der Prozess beendet ! - */ page_dir = pgd_offset(vma->vm_mm, address); if (pgd_none(*page_dir)) goto end_wp_page; @@ -625,20 +617,16 @@ goto bad_wp_pagemiddle; page_table = pte_offset(page_middle, address); pte = *page_table; - /* */ - if (!pte_present(pte)) /* kein Page-Tablen Eintrag vorhanden .... */ + if (!pte_present(pte)) goto end_wp_page; - if (pte_write(pte)) /* Seite darf geschrieben werden ... */ + if (pte_write(pte)) goto end_wp_page; old_page = pte_page(pte); - if (old_page >= high_memory) /* Die Adresse der physischen Seite liegt - ausserhalb des physischen Speichers; */ - goto bad_wp_page; /* daher : Fehler ... */ + if (old_page >= high_memory) + goto bad_wp_page; tsk->min_flt++; /* * Do we need to copy? - * Seite muss dann kopiert werden, wenn sie auch von anderen - * eingeblendet wurde (!=1) ..... */ if (mem_map[MAP_NR(old_page)].count != 1) { if (new_page) { @@ -653,9 +641,6 @@ flush_tlb_page(vma, address); return; } - /* Konnte keine neue Seite angefordert werden, wird der - * Prozess beendet; oom() gibt eine entsprechende Meldung - * aus .... */ flush_cache_page(vma, address); set_pte(page_table, BAD_PAGE); flush_tlb_page(vma, address); @@ -663,8 +648,6 @@ oom(tsk); return; } - /* Seite braucht nicht kopiert werden, da sie nur von diesem Prozess - * eingeblendet wurde. */ flush_cache_page(vma, address); set_pte(page_table, pte_mkdirty(pte_mkwrite(pte))); flush_tlb_page(vma, address); @@ -863,16 +846,11 @@ flush_page_to_ram(pte_page(*page_table)); return; } - /* Der 2.Parameter gibt bereits den Offset in der Inode (Datei) an. */ page = vma->vm_ops->swapin(vma, address - vma->vm_start + vma->vm_offset, pte_val(entry)); if (pte_val(*page_table) != pte_val(entry)) { free_page(pte_page(page)); return; } - /* Bei MAP_PRIVATE wird erst dann eine Kopie erzeugt, wenn der Prozess, - * der private einblendet darauf schreibt. die Aenderungen die durch - * andere erfolgen, bleiben fuer ihn sichtbar; - * 1.Verwendung durch den Buffer-Cache !! */ if (mem_map[MAP_NR(pte_page(page))].count > 1 && !(vma->vm_flags & VM_SHARED)) page = pte_wrprotect(page); ++vma->vm_mm->rss; @@ -890,22 +868,6 @@ * * As this is called only for pages that do not currently exist, we * do not need to flush old virtual caches or the TLB. - * - * Hier werden im wesentlichen folgende Faelle Unterschieden : - * page_present : in der Zwischenzeit wurde der Seiteneintrag - * anderswertig manipuliert; die Seite ist doch schon - * vorhanden. - * swap_page : Die Seite existiert bereits ist aber ausgelagert; sie muss - * aus dem Auslagerungsbereich zurueckgeholt werden. - * nopage ist definiert : es gibt eine spezielle nopage-Funktion fuer diesen - * VMA-Typ. Diese wird aufgerufen um die geforderte Seite zur - * Verfuegung zu stellen. - * keine nopage-Funktion =>> anonymes mmapping liegt vor; es wird eine - * neue, leere Seite zur Verfuegung gestellt. - * - * write_access : ist als boolscher Wert aufzufassen. - * 0 - FALSE : Es erfolgte ein Lesezugriff - * 1 - TRUE : Es erfolgte ein Schreibzugriff */ void do_no_page(struct task_struct * tsk, struct vm_area_struct * vma, unsigned long address, int write_access) @@ -915,11 +877,7 @@ pte_t * page_table; pte_t entry; unsigned long page; - struct vm_area_struct *v_vma; - /* Hier werden, falls noetig, die Page-Verwaltungsstrukturen (pmd, - * pte) erzeugt .... */ - pgd = pgd_offset(tsk->mm, address); pmd = pmd_alloc(pgd, address); if (!pmd) @@ -932,36 +890,16 @@ goto is_present; if (!pte_none(entry)) goto swap_page; - /* Syro : Test : was ist wenn ich die Adresse beibehalte ? - * Antwort : NICHTS !! es gibt in folgenden Dateien nopage-Funktionen : - * fs/fat/mmap.c - * fs/ncpfs/mmap.c - * fs/smbfs/mmap.c - * mm/filemap.c -- die machen alle selbst ein & PAGE_MASK. - * ipc/shm.c -- Hier gibt es gar keine nopage-Komponente. - */ - /* address &= PAGE_MASK; */ /* Es interessiert nur mehr die Seite ??*/ + address &= PAGE_MASK; if (!vma->vm_ops || !vma->vm_ops->nopage) goto anonymous_page; /* * The third argument is "no_share", which tells the low-level code * to copy, not share the page even if sharing is possible. It's * essentially an early COW detection - * 1 = TRUE; wenn VM_SHARED gesetzt ist, dann wird 0 FALSE als 3. - * Parameter uebergeben. Dieser wird als "no_share" interpretiert. - * Also kann die Seite geteilt werden (keine Kopie). - * Ist VM_SHARED nicht gesetzt, ist die Reaktion von der Zugriffsart - * abhaengig : Lesezugriff (0) : no_share = FALSE - Seite gemeinsam - * Schreibzugriff (1) : no_share = TRUE - Seite wird kopiert. - * In der Folge wird davon ausgegangen, dass die Seite wenn noetig - * kopiert wurde. */ page = vma->vm_ops->nopage(vma, address, (vma->vm_flags & VM_SHARED)?0:write_access); - v_vma = find_vma(current->mm, address); - /* Syro : new : der VMA kann in nopage() veraendert werden */ - if ((v_vma != vma) || (v_vma->vm_start != vma->vm_start)) - vma = v_vma; if (!page) goto sigbus; ++tsk->maj_flt; @@ -987,13 +925,6 @@ return; anonymous_page: - /* Alle Entries aller anonymen Mappings werden zuerst mit der - * ZERO_PAGE initialisiert. Um eine eventuell noetige spaetere - * Behandlung vorwegzunehmen, wird im Falle eines Schreibzugriffes - * (write_access) sofort die copy-on-write Prozedur durchgefuehrt. - * Dabei wird eine neue Speicherseite an die Stelle eingeblendet, - * die Seite schreibbar und dirty (ist veraendert worden ..) gesetzt. - */ entry = pte_wrprotect(mk_pte(ZERO_PAGE, vma->vm_page_prot)); if (write_access) { unsigned long page = __get_free_page(GFP_KERNEL); @@ -1009,7 +940,6 @@ return; sigbus: -printk("Send SIGBUS to %d ...\n", current->pid); /* Syro : new : weg */ force_sig(SIGBUS, current); put_page(page_table, BAD_PAGE); /* no need to invalidate, wasn't present */ @@ -1066,8 +996,6 @@ pgd = pgd_offset(vma->vm_mm, address); pmd = pmd_alloc(pgd, address); - /* Syro : Test ... */ - printk("handle_mm_fault is activ ... \n"); if (!pmd) goto no_memory; pte = pte_alloc(pmd, address); @@ -1079,5 +1007,3 @@ no_memory: oom(current); } - - --- /usr/src/linux-work/mm/mprotect.c Tue Oct 19 22:34:19 1999 +++ /usr/src/linux/mm/mprotect.c Wed Sep 11 16:57:19 1996 @@ -104,16 +104,14 @@ return -ENOMEM; *n = *vma; vma->vm_start = end; - vma->vm_rstart = end; /* Syro : new : */ n->vm_end = end; - n->vm_rend = end; - vma->vm_offset += vma->vm_start - n->vm_start; /* Syro : new : */ + vma->vm_offset += vma->vm_start - n->vm_start; n->vm_flags = newflags; n->vm_page_prot = prot; if (n->vm_inode) n->vm_inode->i_count++; if (n->vm_ops && n->vm_ops->open) - n->vm_ops->open(n, VM_OC_NOOP, NULL); /* Syro : new : */ + n->vm_ops->open(n); insert_vm_struct(current->mm, n); return 0; } @@ -129,16 +127,14 @@ return -ENOMEM; *n = *vma; vma->vm_end = start; - vma->vm_rend = start; /* Syro : new : */ n->vm_start = start; - n->vm_rstart = start; - n->vm_offset += n->vm_start - vma->vm_start; + n->vm_offset += n->vm_start - vma->vm_start; n->vm_flags = newflags; n->vm_page_prot = prot; if (n->vm_inode) n->vm_inode->i_count++; if (n->vm_ops && n->vm_ops->open) - n->vm_ops->open(n, VM_OC_NOOP, NULL); /* Syro : new : */ + n->vm_ops->open(n); insert_vm_struct(current->mm, n); return 0; } @@ -160,22 +156,18 @@ *left = *vma; *right = *vma; left->vm_end = start; - left->vm_rend = start; /* Syro : new : */ vma->vm_start = start; - vma->vm_rstart = start; /* Syro : new : */ vma->vm_end = end; - vma->vm_rend = end; /* Syro : new : */ right->vm_start = end; - right->vm_rstart = end; /* Syro : new : */ - vma->vm_offset += vma->vm_start - left->vm_start; + vma->vm_offset += vma->vm_start - left->vm_start; right->vm_offset += right->vm_start - left->vm_start; vma->vm_flags = newflags; vma->vm_page_prot = prot; if (vma->vm_inode) vma->vm_inode->i_count += 2; if (vma->vm_ops && vma->vm_ops->open) { - vma->vm_ops->open(left, VM_OC_COPY, NULL); /* Syro : new : */ - vma->vm_ops->open(right, VM_OC_COPY, NULL); /* Syro : new : */ + vma->vm_ops->open(left); + vma->vm_ops->open(right); } insert_vm_struct(current->mm, left); insert_vm_struct(current->mm, right); @@ -186,24 +178,17 @@ unsigned long start, unsigned long end, unsigned int newflags) { pgprot_t newprot; - int error = 0; + int error; - if (newflags == vma->vm_flags) + if (newflags == vma->vm_flags) return 0; newprot = protection_map[newflags & 0xf]; - if (start == end) - return 0; - - /* Syro : new : Jeder Wert zwischen vm_start und vm_rstart gilt - * als Anfang des VMAs. */ - if (start <= vma->vm_rstart) - if (end >= vma->vm_rend) + if (start == vma->vm_start) + if (end == vma->vm_end) error = mprotect_fixup_all(vma, newflags, newprot); else error = mprotect_fixup_start(vma, end, newflags, newprot); - /* Syro : new : Jeder Wert zwischen vm_rend und vm_end gilt als - * Ende des VMAs. */ - else if (end >= vma->vm_rend) + else if (end == vma->vm_end) error = mprotect_fixup_end(vma, start, newflags, newprot); else error = mprotect_fixup_middle(vma, start, end, newflags, newprot); @@ -215,101 +200,26 @@ return 0; } -/* Kernel Report : Returnwrte passen nicht. lt OpenGroup UNIX98 gibts gar - * kein EFAULT. Diese sollten alle ENOMEM bringen. - * Aenderung des Verhaltens in Bezug auf den uebergebenen Bereich : - * Der mprotect()-Aufruf bekommt einen Bereich uebergeben, der durch die - * Startadresse und die Laenge angegeben wird. Fuer die Adresse gilt, dass - * sie auf einer Seitengrenze liegen muss. Die Laenge kann beliebig angegeben - * werden. mprotect() zeigt nun das Verhalten, dass das, sich aus diesen - * beiden Werten ergebende Bereichsende, wenn es nicht auf eine Seitengrenze - * faellt, selbsttaetig auf die naechsthoehere Grenze gesetzt wird. - * Damit kann es aber vorkommen, dass Teile des eingeblendeten Objektes - * von dieser Aenderung betroffen sind, von denen das gar nicht beabsichtigt - * ist. - * Es gibt zwei andere Moeglichkeiten in dieser Situation zu entscheiden : - * 1: Man sorgt dafuer, dass die Operation auf kein Teil angewendet wird, - * von dem es nicht explizit verlangt wurde. Dieses Verhalten wird durch - * das Abrunden auf die naechstkleinere Seitengrenze erreicht; es ist damit - * genau die gegenteilige Vorgehensweise zu der gegebenen. - * 2: Man zwingt den Programmierer genau anzugeben wie vorzugehen ist, indem - * man die Funktion in einem solchen Fall mit einem Fehler beendet. Es - * werden dann nur solche Wertepaare akzeptiert, bei denen der Endwert - * ebenfalls auf einer Seitengrenze zu liegen kommt. - * Es gebe natuerlich noch die Moeglichkeit, das Programmierinterface in der - * Art zu erweitern, dass die Art des Verhaltens explizit angegeben werden - * kann. - * Weiters muss hier natuerlich auch die Aenderung in der Darstellung des VMAs - * beruecksichtigt werden (Wertepaar realer Anfang / reales Ende). So sind - * Werte die nicht auf einer Seitengrenze liegen dann zulaessig, wenn sie im - * Intervall [vm_start, vm_rstart] bzw [vm_rend, vm_end] liegen. - * Das hier implementierte Verhalten ist das in Punkt 2 angegebene. - * (U.U. sollte man doch noch auf ein konservatives Verhalten umstellen.) - * Alternativ wird das konsequente konservative Verhalten ebenfalls - * Implementiert. Es kann ueber den Switch __KONS_VMM aktiviert werden. - */ - asmlinkage int sys_mprotect(unsigned long start, size_t len, unsigned long prot) { - unsigned long nstart, end = start + len, tmp; + unsigned long nstart, end, tmp; struct vm_area_struct * vma, * next; int error; - if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC)) { - printk("(%d) mprotect : prot-error\n",current->pid); - return -EACCES; - /* return -EINVAL; Kernel Report : -EINVAL -EACCES man-page */ - } - - if (end < start) { - printk("(%d) mprotect : end < start\n",current->pid); - /* return -EINVAL; Kernel Report : -EFAULT man-page */ - return -EFAULT; - } - - /* Zuerst werden die beiden Grenz-VMAs bestimmt. */ + if (start & ~PAGE_MASK) + return -EINVAL; + len = (len + ~PAGE_MASK) & PAGE_MASK; + end = start + len; + if (end < start) + return -EINVAL; + if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC)) + return -EINVAL; + if (end == start) + return 0; vma = find_vma(current->mm, start); - if (!vma || vma->vm_start > start) { - printk("(%d) mprotect : Lower-VMA-error\n",current->pid); + if (!vma || vma->vm_start > start) return -EFAULT; - } - next = find_vma(current->mm, end - 1); - if (!vma || next->vm_start > end - 1){ - printk("(%d) mprotect : Upper-VMA-error\n",current->pid); - return -EFAULT; - } - /* start zwischen start und rstart wird auf start gezogen. */ - start = (start <= vma->vm_rstart) ? vma->vm_start : start; - /* end zwischen rend und end wird auf end gezogen. */ - end = (end >= next->vm_rend) ? next->vm_end : end; - /* Syro : new : hier sind beide Varianten eingebaut (konservativ und - * traditionell); durch Compilerswitch zu aktivieren. */ -#define __KONS_VMM -#ifndef __KONS_VMM - if (start & ~PAGE_MASK) { -printk("(%d) mprotect : start not on page-border\n",current->pid); - return -EFAULT; - } - if (end & ~PAGE_MASK) { -printk("(%d) mprotect : end not on page-border\n",current->pid); - return -EFAULT; - } -#else - /* Konservatives Verhalten : liegt einer oder beide der Werte an einer - * beliebigen Position innerhalb einer Seite, so wird der Wert - * auf die naechste innenliegende Seitengrenze gezogen (es wird nichts - * erfasst von dem es nicht ausdruecklich gefordert wurde). */ - - start = (start & ~PAGE_MASK) ? PAGE_ALIGN(start) : start; - end = (end & ~PAGE_MASK) ? (end & PAGE_MASK) : end; -#endif - - /* end kann durch konservative Rundung unter start rutschen ohne dass - * das einen Fehler bedeutet. */ - if (end <= start) { - printk("(%d) mprotect exit : %lx >= %lx\n",current->pid, start, end); - return 0; - } + for (nstart = start ; ; ) { unsigned int newflags; @@ -317,37 +227,23 @@ newflags = prot | (vma->vm_flags & ~(PROT_READ | PROT_WRITE | PROT_EXEC)); if ((newflags & ~(newflags >> 4)) & 0xf) { - printk("(%d) mprotect : flags-error\n",current->pid); error = -EACCES; break; } - /* Feuert beim letzten VMA - also auch wenn nur einer ... */ + if (vma->vm_end >= end) { error = mprotect_fixup(vma, nstart, end, newflags); break; } - tmp = vma->vm_rend; /* Syro : new : aus vm_end wird vm_rend */ + tmp = vma->vm_end; next = vma->vm_next; error = mprotect_fixup(vma, nstart, tmp, newflags); if (error) break; - - /* Syro : new : Loch am Ende des VMAs : wir brauchen nicht - * weitermachen -->> Fehler */ - if (vma->vm_end != vma->vm_rend) { - printk("(%d) mprotect : End-Hole-error\n",current->pid); - error = -EFAULT; /* lt OG : -ENOMEM */ - break; - } - nstart = tmp; vma = next; - /* Syro : new : Wenn der naechste VMA einen Offset hat, dann - * darf das Ende in diesem 'freien' Anfangsbereich liegen. */ - if (!vma || vma->vm_start != nstart || - ((vma->vm_start != vma->vm_rstart) && - (end > vma->vm_rstart))) { + if (!vma || vma->vm_start != nstart) { error = -EFAULT; break; } @@ -355,17 +251,3 @@ merge_segments(current->mm, start, end); return error; } - - - - - - - - - - - - - - --- /usr/src/linux-work/mm/mlock.c Wed Jul 28 21:44:39 1999 +++ /usr/src/linux/mm/mlock.c Thu Oct 16 00:58:46 1997 @@ -33,15 +33,13 @@ return -EAGAIN; *n = *vma; vma->vm_start = end; - vma->vm_rstart = end; /* Syro : new : */ n->vm_end = end; - n->vm_rend = end; /* Syro : new : */ - vma->vm_offset += vma->vm_start - n->vm_start; + vma->vm_offset += vma->vm_start - n->vm_start; n->vm_flags = newflags; if (n->vm_inode) n->vm_inode->i_count++; if (n->vm_ops && n->vm_ops->open) - n->vm_ops->open(n, VM_OC_NOOP, NULL); /* Syro : new : */ + n->vm_ops->open(n); insert_vm_struct(current->mm, n); return 0; } @@ -56,15 +54,13 @@ return -EAGAIN; *n = *vma; vma->vm_end = start; - vma->vm_rend = start; /* Syro : new : */ n->vm_start = start; - n->vm_rstart = start; /* Syro : new : */ n->vm_offset += n->vm_start - vma->vm_start; n->vm_flags = newflags; if (n->vm_inode) n->vm_inode->i_count++; if (n->vm_ops && n->vm_ops->open) - n->vm_ops->open(n, VM_OC_NOOP, NULL); /* Syro : new : */ + n->vm_ops->open(n); insert_vm_struct(current->mm, n); return 0; } @@ -85,21 +81,17 @@ *left = *vma; *right = *vma; left->vm_end = start; - left->vm_rend = start; /* Syro : new : */ vma->vm_start = start; - vma->vm_rstart = start; /* Syro : new : */ vma->vm_end = end; - vma->vm_rend = end; /* Syro : new : */ right->vm_start = end; - right->vm_rstart = end; /* Syro : new : */ vma->vm_offset += vma->vm_start - left->vm_start; right->vm_offset += right->vm_start - left->vm_start; vma->vm_flags = newflags; if (vma->vm_inode) vma->vm_inode->i_count += 2; if (vma->vm_ops && vma->vm_ops->open) { - vma->vm_ops->open(left, VM_OC_COPY, NULL); /* Syro : new : */ - vma->vm_ops->open(right, VM_OC_COPY, NULL); /* Syro : new : */ + vma->vm_ops->open(left); + vma->vm_ops->open(right); } insert_vm_struct(current->mm, left); insert_vm_struct(current->mm, right); @@ -142,115 +134,23 @@ return retval; } -/* Laut man-Page und UNIX-Standard darf im Fehlerfall keine Aenderung am - * Lock-Status einer Seite vorgenommen werden. D.h. es muessen alle erfolgten - * Aenderungen rueckgaengig gemacht werden. das ist aber nicht der Fall. - * das muss erst implementiert werden. */ - static int do_mlock(unsigned long start, size_t len, int on) { - unsigned long nstart, tmp, end = start + len; - unsigned long locked; - unsigned long lock_limit; + unsigned long nstart, end, tmp; struct vm_area_struct * vma, * next; int error; - /* werden nur feur Diagnose gebraucht ... */ -unsigned long ostart = start, olen = len; - /* Syro : new : suser-test wird als erster Test in den aufrufenden - * Funktionen durchgefuehrt. if (!suser()) - return -EPERM; */ - /* Syro : new : Die diversen Abfragen werden umgestaltet und - * an andere Positionen verlagert. */ - /* len = (len + ~PAGE_MASK) & PAGE_MASK; + return -EPERM; + len = (len + ~PAGE_MASK) & PAGE_MASK; end = start + len; if (end < start) return -EINVAL; if (end == start) - return 0; */ - - /* Dieser Fall muss sofort behandelt werden, da diese Situation auch - * durch die Werte-Anpassung entstehen kann, dann aber mit return 0 - * zu behandeln ist. */ - if (end < start) - return -EINVAL; - - /* Syro : new : Um zu entscheiden, ob auf- oder abgerundet werden - * muss, wird getestet, ob der Anfang bzw das Ende mit den ev. - * nicht-page-alligned Bereichsgrenzen zusammenfaellt (wenn dem so - * ist, wird aufgerundet). - * Zuerst werden die beiden betreffenden VMAs ermittelt. */ - + return 0; vma = find_vma(current->mm, start); if (!vma || vma->vm_start > start) return -ENOMEM; - next = find_vma(current->mm, end-1); - if (!next || next->vm_start > end) - return -ENOMEM; - - if ( start & ~PAGE_MASK ) { - if (start > vma->vm_rstart) { - len -= PAGE_SIZE - (start & ~PAGE_MASK); - start = PAGE_ALIGN(start); - } - else { - len += (start & ~PAGE_MASK); - start &= PAGE_MASK; - } - } - if ( end & ~PAGE_MASK ) { - if (end < next->vm_rend) { - len -= (end & ~PAGE_MASK); - end &= PAGE_MASK; - } - else { - len += PAGE_SIZE - (end & ~PAGE_MASK); - end = PAGE_ALIGN(end); - } - } - /* Wenn der Bereich nur innerhalb einer Page liegt und dabei aber - * nicht den gesamten gueltigen Bereich innerhalb dieser Seite - * umfasst, tritt genau der Fall ein, wo im Sinne des konservativen - * Verhaltens die Operation nicht auf Teile fuer die es nicht - * verlangt wurde angewendet werden darf. Dabei kann es dazu kommen, - * dass start == end ist bzw der end-Wert sogar vor dem start-Wert - * liegt. In dem Fall wird keine Speicherseite gelocked und es darf - * aber auch kein Fehler angezeigt werden. */ -#define __SYRO -#ifdef __SYRO -printk ("(%d) mlock : old : %lx - %lx (%lx)\n", -current->pid, ostart, ostart+olen, olen); -printk ("(%d) mlock : new : %lx - %lx (%lx)\n", -current->pid, start, end, len); -#endif - if (end <= start) - return 0; - - - /* Syro : new : Werte-Tests hierher verschoben. */ - - if (on) { /* nur beim mlock()-Aufruf. */ - locked = len >> PAGE_SHIFT; - locked += current->mm->locked_vm; - - lock_limit = current->rlim[RLIMIT_MEMLOCK].rlim_cur; - lock_limit >>= PAGE_SHIFT; - - /* check against resource limits */ - if (locked > lock_limit) - return -ENOMEM; - - /* we may lock at most half of physical memory... */ - /* (this check is pretty bogus, but doesn't hurt) */ - if (locked > (MAP_NR(high_memory) >> 1)) - return -ENOMEM; - } - - /* Syro : new : wird an den Anfang verschoben ... */ - /* vma = find_vma(current->mm, start); - if (!vma || vma->vm_start > start) - return -ENOMEM; */ for (nstart = start ; ; ) { unsigned int newflags; @@ -282,40 +182,12 @@ return error; } -/* mlock : Verhindert die Auslagerung der Speicherseiten, der - * zusammenhaengenden VMAs im angegebenen angegebenen Intervall. - * Lt. Definition und man-Page darf im Fehlerfall keine Veraenderung - * an einem VMA des Bereiches durchgefuehrt werden. Diese Bedingung - * ist hier NICHT erfuellt. - * Konservatives Verhalten : Die geforderte Operation wird nur auf jene - * Bereiche angewendet, fuer die es verlangt ist. Wird eine Seite nicht zur - * Gaenze durch das Intervall erfasst, so wird diese Seite nicht gesperrt. - * - * Konsequenzen der erweiterten VMAs : Die Erweiterung der VMAs auf nicht- - * page-alligned Grenzen hat fuer diese Funktion nur in einigen Sonderfaellen - * eine Verhaltensaenderung zur Folge. - * Grundsaetzlich ist es jetzt auch moeglich als Bereichsanfang auch einen - * Wert anzugeben, der nicht auf einer Seitengrenze liegt. Dieser kann aber - * nur dann angenommen werden, wenn er mit dem realen Anfang des VMAs - * zusammenfaellt (bzw zwischen start und rstart liegt). Ansonsten wuerde - * sich das Problem ergeben, dass fuer eine Speicherseite zwei verschiedene - * lock-Bedingungen gelten. - * Fuer das obere Ende des Bereiches gilt folgendes : - * Faellt der Wert nicht mit dem Ende eines VMAs oder einer Seitengrenze - * zusammen, so wird der Wert auf die naechste Seitengrenze abgerundet. - * Dieses Abrunden ist auch der Unterschied zum ueblichen Verhalten, bei dem - * in diesem Fall aufgerundet wird. - */ - asmlinkage int sys_mlock(unsigned long start, size_t len) { + unsigned long locked; + unsigned long lock_limit; - /* Syro : new : suser-test sofort .... */ - if (!suser()) - return -EPERM; - /* Syro : new : Die Aufbereitung der Werte und die Leangentests - * werden alle in die zentrale do_mlock-Funktion verschoben. */ - /* len = (len + (start & ~PAGE_MASK) + ~PAGE_MASK) & PAGE_MASK; + len = (len + (start & ~PAGE_MASK) + ~PAGE_MASK) & PAGE_MASK; start &= PAGE_MASK; locked = len >> PAGE_SHIFT; @@ -323,27 +195,23 @@ lock_limit = current->rlim[RLIMIT_MEMLOCK].rlim_cur; lock_limit >>= PAGE_SHIFT; - */ + /* check against resource limits */ - /* if (locked > lock_limit) + if (locked > lock_limit) return -ENOMEM; - */ + /* we may lock at most half of physical memory... */ /* (this check is pretty bogus, but doesn't hurt) */ - /* if (locked > (MAP_NR(high_memory) >> 1)) + if (locked > (MAP_NR(high_memory) >> 1)) return -ENOMEM; - */ + return do_mlock(start, len, 1); } asmlinkage int sys_munlock(unsigned long start, size_t len) { - /* Syro : new : suser-test sofort .... */ - if (!suser()) - return -EPERM; - /* Syro : new : nach do_mlock verschoben ..... */ - /* len = (len + (start & ~PAGE_MASK) + ~PAGE_MASK) & PAGE_MASK; - start &= PAGE_MASK; */ + len = (len + (start & ~PAGE_MASK) + ~PAGE_MASK) & PAGE_MASK; + start &= PAGE_MASK; return do_mlock(start, len, 0); } @@ -401,5 +269,3 @@ { return do_mlockall(0); } - - --- /usr/src/linux-work/fs/pipe.c Thu Mar 9 18:21:41 2000 +++ /usr/src/linux/fs/pipe.c Sun Nov 15 19:33:14 1998 @@ -4,138 +4,8 @@ * Copyright (C) 1991, 1992 Linus Torvalds */ -/* New : Syro - */ - -/* Offen -- Offen -- Offen -- Offen -- Offen -- Offen -- Offen -- Offen - -fstat ???? - -readers/writers Erhoehung durch msync/unmap gefixed ..... - -Der normale write-Pointer blockiert woff, was aber nicht sein darf !!! - OK ... - -Prozess beenden : Buffer-Grenzen nachziehen (wie msync) - durch korrekte munmap-Behandlung .... OK - - -inode-Zeitstempel setzen ..... OK - -read/write aus der eingeblendeten Pipe - OK .... - -Rueckstellen der Pipe in den Normal-Modus ... OK - -Was ist mit der Inode-Share-Liste ?? ... wird nicht gebraucht. - -msync : msync Bereich groesser als buffer ? jetzt error - ist -aber nicht befriedigend >>> jetzt kann im Prinzip beliebig gesynct werden. -ein sync des ganzen VMA hat aber ein unmap zur Folge; die Werte werden genauso -wie bei jedem anderen sync angepasst. .... OK - - -signale abfragen nach wakeup - sollte bereits ueberall sein ..... (09/10/99) - - -auto-commit :: wird in pipemap_nopage gechecked .... OK - -Signale .... (Anton sagt daweil nicht so wichtig) : macht so wie bei - bei den normalen Pipes; Map-Prozess muss aber Signalbehandlung - machen; SIGPIPE **und** SIPBUS .... OK - - - - -clone (fork = clone COPYVM) : - COPYVM : alle Child-Pages werden CoW zum Parent gesetzt -==>> Pipe : WRITE ist in keiner Weise betroffen; einfach ein neuer - Prozess, der die Write-Pipe einblendet (mit den - aktuellen Werten des Parent). - READ - -Alle Operationen auf VMAs (unmap, remap, lock, mprotect) :: - Es darf zu keiner Teilung des VMAs kommen, da ansonst die - Zuordnung VMA-Position und Pipe-Buffer-Position nicht mehr - moeglich ist. - Bemerkung : An sich waehre eine Teilung eines VMAs in mehrere Teile - moeglich, wenn man genauso vorgeht, als wenn der Prozess die Pipe - weitere male einblendet. - sollte jetzt genauso sein ... wegen unmap/open (09/10/99) - - - -*/ - -/* Bemerkungen :: - -- (ist schon erledigt bleibt aber als Hinweis) -pipemap_msync : Msync MUSS ein unmap durchfuehren, da ansonst der Zugriff -auf die commiteten Bereiche nicht verhindert werden kann; Um die Adress- -korrektur muss sich der Anwender kuemmern !! -- das muss er ja bei einem -munmap() auch selbst machen .... -Damit werden Zugriffe unterhalb des erlaubten Bereiches (Write/Read) -schon durch find_vma() erkannt .... bzw wird erst dadurch wieder die -Voraussetzung geschaffen, einen Seitenfehler beim Zugriff auf eine solche -Adresse zu verursachen ... - -Zusammenspiel von unmap/msync mit den read/write Anfangswerten : - Ein munmap auf den Bereich einer Pipe-Einblendung ist in dem Fall wo - dadurch kein bestimmender Pipe-Buffer-Wert betroffen ist ganz - unproblematisch : Die wesentliche Behandlung erfolgt bereits in der - allgemeinen munmap()-Funktion (ev Teilung des Bereiches bei - Band-Ausblendung); Erzeugung eines neuen Mapper-Entrys durch open()- - Aufruf; - Ansonst ist nur die Korrektur der Werte vma_start und act_pos des Mapper- - Entrys notwendig. - Anders ist der Fall, wenn dabei ein bestimmender Grenzwert betroffen ist. - War der Anfangswert bestimmend fuer den aktuellen Grenzwert (Anfang des - read oder write Bereiches), dann ist wie bei einem msync vorzugehen. - Wobei allerdings noch die Situation in der nur ein einziger Mapper vorhanden - ist gesondert behandelt wird. In diesem Fall kommt dem Positionswert fuer - den Sys-Call-Zugriff (read()/write()) anders als in allen anderen Faellen, - eine bestimmende Funktion zu : normalerweise wird dieser Zeiger einfach - auf die neue Anfangsposition nachgezogen. Nur in dem Fall wo bei einem - munmap mit nur einem Mapper der Grenzwert ueber die Sys-Call Position - hinaus geschoben wird, wird dieser bis maximal zum naechsten Sync der - Bereichs-Anfangswert. - Das bedeutet vor allem fuer die Read-Seite, dass dann wenn die read()- - Position bestimmend ist, durch einen read()-Aufruf auch ein buf_shift() - ausgeloest werden muss. Genauso wie im Fall wo sich die Pipe im mmap-Mode - befindet und kein Read-Mapper vorhanden ist. - - Begruendung : durch ein munmap wird ja nicht der Inhalt der Seiten zum - Lesen freigegeben; dieser sollte also nicht auf die Leseseite - gelangen. Durch das Beibehalten der Write()-Position wird ein - ueberschreiben der Inhalte ermoeglicht. - Allerdings : bei einem nachfolgenden msync springt Anfangswert sehr wohl - ueber die unguelltigen Seiten ! - machen alle Mapper ein munmap auf einen Bereich gelangen die - Inhalte ebenfalls auf die Leseseite. - Abhilfe : man sollte zu jeder Seite des Buffers ein Attribut synced ablegen - koennen ...... - ===>>> genau das wurde auch realisiert !!! - -- sync des Lesebereiches ueber den Anfang des Schreibbereiches hinaus : - ist natuerlich moeglich; der Prozess muss natuerlich die Infos aus ioctl() - ueber die Groesse des Buffers richtig auswerten (im Testprogramm scheint das - korrekt gemacht zu werden. -> anschauen). - Interessant ist der Fall, wo ein solches Sync zu einem Nachziehen der read() - Position fuehrt. Meine Festlegung : die read()-Position kann natuerlich nicht - die write()-Position ueberholen. Ist auch das tatsaechliche Verhalten. -- sync des Schreibbereiches ueber das Buffer-Ende hinaus : - Soll moeglich sein; muss aber in buf_shift abgefangen werden. - Die Werte rutschen durch read() oder msync/unmap von Lesebereichen nach - und nach ins Buffer-Fenster. - - - -*/ - - #include -#include + #include #include #include @@ -143,540 +13,12 @@ #include #include #include -#include /* syro : new - wegen kmalloc, kfree */ - -#include /* Syro : new - wegen MAP_xxx Konstanten */ -#include /* Syro : new - wegen diverser PT-Funktionen */ - -static void buf_shift(struct inode *, unsigned long, int); -static void rwvals(char *, struct inode *); -static void rwcnts(char *, struct inode *); -static int pipemap_sync(struct vm_area_struct *, unsigned long, size_t, unsigned int); -static int psync (struct vm_area_struct *, unsigned long, size_t, char); -static void do_pclose (struct inode *, int); - -/* DiagnoseFunktion ... */ -static void pkm(struct pipe_mapper *); -static void pkpipe(struct inode *); -static void pkmapper(struct pipe_mapper *); -/* Lokale Macros/Definitionen :: */ - -#define CPID current->pid - -#define MSYNC_CALLS_PSYNC 1 -#define UNMAP_CALLS_PSYNC 2 - -#define BOFF(idx, inode) ((idx * PAGE_SIZE) + MPIPE_BASE(*inode)) /* * Define this if you want SunOS compatibility wrt braindead * select behaviour on FIFO's. */ #undef FIFO_SUNOS_BRAINDAMAGE -/* -static int mpipe_write(struct inode *, struct file *, const char *, int); -static int mpipe_read(struct inode *, struct file *, char *, int); -*/ - -static void pm_sigpipe(struct pipe_mapper *pmp) { - - if (PM_SIGPIPE(pmp)) return; - PM_FLAG(pmp) |= PM_SIG_PIPE; - send_sig(SIGPIPE,current,0); - return; -} - -/* Hat die wichtigen Datenstrukturen wiederhergestellt .... - * Braucht aber eine act_addr - Komponente in der Task-Struktur ... */ -/* -static int rest_val(struct vm_area_struct **vmp, struct inode **ip, - struct pipe_mapper **pmp, unsigned long *ap){ - - int retv = 0; - struct vm_area_struct *vp; - struct pipe_mapper *mp; - -printk("[%d] ************ Restore Values ******************\n",CPID); - if (vmp == NULL) { - printk("[%d] No vmp -- return ...\n",CPID); - return 1; - } - if (ap != NULL) { - if(*ap != current->act_addr) -printk("[%d] *ap (0x%lx) != act_addr (0x%lx)\n",CPID,*ap, current->act_addr); - *ap = current->act_addr; -printk("[%d] Restore address : 0x%lx\n",CPID,current->act_addr); - } - else -printk("[%d] No restore for address...\n",CPID); - - vp = find_vma(current->mm, current->act_addr); - if (vp == NULL) { - printk("[%d] Can't restore VMA (find-vma)\n",CPID); - retv = 1; - } - else { - if ((*vmp)->vm_start != vp->vm_start) -printk("[%d] vmp (0x%lx) != vp (0x%lx)\n",CPID,(*vmp)->vm_start, vp->vm_start); - *vmp = vp; - if (! ((*vmp)->vm_start <= current->act_addr && - current->act_addr <= (*vmp)->vm_end)) { - printk("[%d] Got wrong VMA (0x%lx)\n",CPID,(*vmp)->vm_start); - retv = 1; - } -if (! retv) -printk("[%d] Restore VMA : 0x%lx\n",CPID,(*vmp)->vm_start); - } - if (pmp == NULL) { - printk("[%d] No Map-Entry-Pointer -- return ...\n",CPID); - return retv; - } - if ((mp = VMA_PMAP((*vmp))) == NULL) { - printk("[%d] Can't restore Pipe-Mappper-Pointer\n",CPID); - retv = 1; - } - else { - if (PM_START(*pmp) != PM_START(mp)) -printk("[%d] pmp (0x%lx) != mp (0x%lx)\n",CPID,PM_START(*pmp),PM_START(mp)); - *pmp = mp; - if (PM_START(*pmp) != (*vmp)->vm_start) { - printk("[%d] PM-Entry : p 0x%lx != v 0x%lx\n", - CPID,PM_START(*pmp),(*vmp)->vm_start); - retv = 1; - } -if (! retv) -printk("[%d] Restore PM-Entry : 0x%lx\n",CPID,PM_START(*pmp)); - } - if (ip == NULL) { - printk("[%d] No inode-Pointer -- return ...\n",CPID); - return retv; - } - if ((*ip)->i_ino != ((*vmp)->vm_inode)->i_ino) -printk("[%d] ip (%d) != vm-ip (%d)\n", - CPID,(*ip)->i_ino, ((*vmp)->vm_inode)->i_ino); - if ((*ip = (*vmp)->vm_inode) == NULL) { - printk("[%d] Can't restore INODE\n",CPID); - retv = 1; - } -if (! retv) -printk("[%d] Restore Inode : 0x%lu\n",CPID,(*ip)->i_ino); - - return retv; -} -*/ - -/* Gibt die Elemente einer Wait-Queue aus ... */ - -static int qlen(struct inode * inode) { - int cnt = 0; - struct wait_queue * sqp, *qp; - - sqp = qp = PIPE_WAIT(*inode); - printk("[%d] &PIPE_WAIT : 0x%lx - PIPE_WAIT : 0x%lx\n", - CPID,(unsigned long) &PIPE_WAIT(*inode), - (unsigned long) PIPE_WAIT(*inode)); - - /* if (PIPE_MODE(*inode) == NORM_PIPE) return 0; */ - - while (sqp != NULL && sqp->next != qp) { - cnt++; - printk("Queue-Entry %d : %d (0x%lx)\n", - cnt,(sqp->task)->pid, (unsigned long)sqp->next); - sqp = sqp->next; - } - if (sqp == NULL) printk("[%d] qlen-end : NULL\n",CPID); - if (sqp == qp) printk("[%d] qlen-end sqp == qp (0x%lx)\n", - CPID, (unsigned long) sqp->next); - printk("[%d] %d Entries in 0x%lx (inode %lu)....\n", - CPID,cnt,(unsigned long) qp,inode->i_ino); - return cnt; -} - -/* Syro : new : atomic_op() : - * Ist der Bedarf kleiner als der grundsaetzlich zur Verfuegung stehende - * Buffer, so kann die Operation atomar ausgefuehrt werden. Es muss - * aber ev. erst auf das Vorhandensein eines entsprechend Grossen - * Bereiches (read/write) gewartet werden. Ansonsten kann die Operation - * sowieso nur mit Unterbrechungen durchgefuhrt werden. - * Insbesondere kann bzw darf, wenn hier mit not-atomic entschieden wurde - * ein wait in get_pos_baddr() erfolgen (bei Bufferobergrenzen- - * ueberschreitung). - */ - -static inline int atomic_op(struct inode * inode, - int count, unsigned long offset) { - - int sidx, eidx, i; - - if (count > PIPE_BUF_SIZE(*inode)) - return 0; - - if (PIPE_MODE(*inode) == NORM_PIPE) - return 1; - - /* Bedarf uebersteigt den Buffer der mmap-Pipe. */ - - if (offset + count > PIPE_BUF_SIZE(*inode)) - return 0; - - sidx = PM_PTEIDX(offset); - eidx = PM_PTEIDX(offset + count); - - /* Wenn eine der Seiten ausgelagert ist, dann kann kein - * atomic write garantiert werden, da zum Einlagern die - * Pipe freigegeben werden muss. */ - - - for (i = sidx; i <= eidx; i++) - if (! pte_present(MPIPE_PTE(MPIPE_PLIST(*inode)[i]))) - return 0; - /* Platz fuer weitere Bedingungen die fuer atomic read/write - * erfuellt sein muessen. */ - - return 1; -} - -/* mapcnt : Ermittelt die Anzahl der Prozesse, die eine Pipe eingeblendet - * haben. */ - -static int mapcnt(struct pipe_mapper * pminf) { - int cnt = 0; - - while (pminf) { - cnt++; - pminf = pminf->next; - } - return cnt; -} - -/* Syro : new : */ - -static inline char *get_pos_baddr(struct inode * inode, - unsigned long offset, int mode) { - - int idx; - char * page; - - /* Modusabfrage ist bei endgueltiger Umstellung des Pipe-Buffers - * nicht mehr noetig .... */ - if (PIPE_MODE(*inode) == NORM_PIPE) - return (char *) (PIPE_BASE(*inode) + (offset & ~PAGE_MASK)); - - /* NPIPE_START bzw NPIPE_WSTART sind Offsets im ganzen Pipe-Buffer und - * muessen daher um die aktuelle Basis des aktiven Buffers vermindert - * werden. */ - offset -= MPIPE_BASE(*inode); - - idx = PM_PTEIDX(offset); - - if (idx >= PIPE_BUF_PAGES(*inode)) - return NULL; - - - /* Wenn an dieser Stelle des Buffers noch keine Seite vorhanden ist, - * muss eine neue Seite angefordert werden. */ - if (pte_none(MPIPE_PTE(MPIPE_PLIST(*inode)[idx]))) { - if (mode == FMODE_READ) { - printk("get_pos_baddr : page_non in read-pipe should never happen !!\n"); - return NULL; - } - /* Schreibzugriff : ganz neue Seite; muss erst angelegt - * und in die PTE-Liste eingetragen werden. */ - page = (char *) get_free_page(GFP_USER); - if (page == NULL) { - printk("get_pos_baddr : can't get free page !\n"); - return NULL; - } - MPIPE_PTE(MPIPE_PLIST(*inode)[idx]) = mk_pte((unsigned long) - page, - PAGE_SHARED); - pb_init(MPIPE_PLIST(*inode)[idx]); - } - - /* An dieser Stelle ist sichergestellt, dass an der Stelle idx - * der PTE_Liste ein Page-Table Entry zu finden ist. */ - - /* Eine ZERO-Page braucht nur bei einem Memory-Zugriff ersetzt - * werden. Bei einem read() ist das nicht notwendig, da nicht in die - * Seite hineingeschrieben werden kann. */ - - if (mode == FMODE_READ && - ! (MPIPE_PFLAGS(MPIPE_PLIST(*inode)[idx]) & PBF_SYNC)) { - printk("[%d] get_pos_baddr : READ detect unmapped page %d\n", - CPID,idx); - memset((void *) pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[idx])), - 0,PAGE_SIZE); - pb_sync(MPIPE_PLIST(*inode)[idx]); - } - - if (mode == FMODE_WRITE) { - pb_sync(MPIPE_PLIST(*inode)[idx]); - pb_use(MPIPE_PLIST(*inode)[idx]); - } - - return (char *) (pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[idx])) + - (offset & ~PAGE_MASK)); -} - -/* wait_backswitch : - * - */ - -static int wait_backswitch (struct inode * inode, int mode) { - - int sidx, eidx, i; - - /* Wenn die Pipe nicht im Uebergangsmodus ist, braucht der - * Uebergang natuerlich nicht erfolgen. */ - if(PIPE_MODE(*inode) != MTON_PIPE) return 0; - - /* Wenn sich beide Zeiger in der selben Seite befinden, dann - * kann das Ruecksetzen in den Normal-Modus erfolgen. Ansonsten - * wird gewartet bis die Pipe entsprechend weit ausgelesen wurde. */ - - while (PIPE_LOCK(*inode)) { - printk("[%d] backswitch : wait until pipe-unlock !\n",CPID); - interruptible_sleep_on(&PIPE_WAIT(*inode)); - if (current->signal & ~current->blocked) { - printk("[%d] backswitch : signal force TERM ...\n", - CPID); - send_sig(SIGTERM,current,1); - return 1; - } - } - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - - sidx = PM_PTEIDX(NPIPE_START(*inode) - MPIPE_BASE(*inode)); - eidx = PM_PTEIDX(NPIPE_WSTART(*inode) - MPIPE_BASE(*inode)); - - /* Beim Aufruf in der read-Funktion darf nicht auf die Reduktion - * des Buffers gewartet werden (geht ja nur durch Auslesen) */ - if ((sidx != eidx) && - ! ((sidx + 1) == eidx && ! (NPIPE_WSTART(*inode) & ~PAGE_MASK))) { - PIPE_LOCK(*inode)--; /* Pipe wird freigegeben .. */ - wake_up_interruptible(&PIPE_WAIT(*inode)); - if (mode == FMODE_READ) return 0; - return 1; - } - - /* Neue Speicherseite als Pipe-Buffer setzen. */ - if (!(PIPE_BASE(*inode) = (char*) vmalloc((unsigned long) PIPE_BUF))) { - printk("[%d] backswitch : can't vmalloc mem ...\n", CPID); - PIPE_LOCK(*inode)--; /* Pipe wird freigegeben .. */ - wake_up_interruptible(&PIPE_WAIT(*inode)); - printk("[%d] backswitch : nomem-error force kill ...\n", CPID); - send_sig(SIGKILL,current,1); - return 1; - } - - if (PIPE_LEN(*inode)) { - if (! pte_none(MPIPE_PTE(MPIPE_PLIST(*inode)[sidx]))) { - /* Hier muss swapin eingebaut werden */ - if (! pte_present(MPIPE_PTE(MPIPE_PLIST(*inode)[sidx]))){ - printk("[%d] backswitch : pte_present-error force TERM ...\n", CPID); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - printk("[%d] terminated ...\n", CPID); - send_sig(SIGTERM,current,1); - return 1; - } - - /* Inhalt kopieren. */ - memcpy((void *) PIPE_BASE(*inode),\ - (void *) pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[sidx])), - PAGE_SIZE); - if (__HIGH(*inode)) - printk("backswitch : memcpy done\n"); - } - } - - /* Loeschen der Buffer-Liste und Freigabe der darin ev. noch - * gebundenen Speicherseiten. */ - if (MPIPE_PLIST(*inode) != NULL){ - - for (i = 0; i < PIPE_BUF_PAGES(*inode); i++) - if (! pte_none(MPIPE_PTE(MPIPE_PLIST(*inode)[i]))){ - char * page; - /* Korrektur des Use-Counts der Page ... */ - page = (char *) pte_page(MPIPE_PTE( - MPIPE_PLIST(*inode)[i])); - if (mem_map[MAP_NR(page)].count != 1){ - mem_map[MAP_NR(page)].count = 1;} - free_pte(MPIPE_PTE(MPIPE_PLIST(*inode)[i])); - pte_clear(&(MPIPE_PTE(MPIPE_PLIST(*inode)[i]))); - } - /* Freigabe des Speichers der Page-Liste. */ - kfree((void *) MPIPE_PLIST(*inode)); - } - MPIPE_PLIST(*inode) = NULL; - - NPIPE_START(*inode) -= MPIPE_BASE(*inode); - NPIPE_WSTART(*inode) -= MPIPE_BASE(*inode); - /* Steht die Schreib-Position am Seitenend, wird si auf den - * Anfang gezogen, da es ansonst zu einem Irrtum beim naechsten - * mmap der Pipe kommen kann ... */ - if (NPIPE_WSTART(*inode) == PAGE_SIZE) NPIPE_WSTART(*inode) = 0; - MPIPE_START(*inode) = 0; - MPIPE_BASE(*inode) = 0; - PIPE_BUF_SIZE(*inode) = PIPE_BUF; - PIPE_MODE(*inode) = NORM_PIPE; - PIPE_DLEV(*inode) = INIT_PD; - - PIPE_LOCK(*inode)--; /* Pipe wird freigegeben .. */ - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; -} - -/* - * read_last_page : Wenn es keinen Schreibzugriff mehr auf eine Pipe - * gibt, aber noch Read-Prozesse auf den Rest warten, wird - * der Rest der letzten Seite mit EOF (-1) gefuellt und - * die Seite zum Lesen freigegeben. Ansonst ist keine - * vernuenftige Behandung des Pipe-Endes im eingeblendeten - * Zustand moeglich. Die Seite bleibt aber nachwievor zum - * Schreiben offen ! Das kann im Falle einer Fifo tatsaechlich - * noch erfolgen. Wird in pipemap_nopage aufgerufen. - */ - -static unsigned long read_last_page (struct inode *inode, int idx, - struct pipe_mapper *pmp) { - int pidx, len; - char *init_pos = NULL; - - /* Bedingung aus pipe_reset() uebernommen; beschreibt den Fall, wo - Rest-Daten in der Pipe sind und keine Schreiber mehr existieren; - Bedingung wird hier negiert -> Ausstieg sollange dieser Sonderfall - noch nicht eingetreten ist. */ - if (!(!PIPE_WRITERS(*inode) && PIPE_READERS(*inode) && - PIPE_LEN(*inode) && PIPE_MODE(*inode) != NORM_PIPE)) - return 0; - - /* Lesemapper muessen vorhanden sein */ - if (! mapcnt(MPIPE_READERS(*inode))) - return 0; - - /* Index der letzten Seite */ - pidx = PM_PTEIDX(NPIPE_WSTART(*inode) - MPIPE_BASE(*inode)); - - /* Kein Letzte-Seite Problem, da letzte Seite voll ist. - * Da aber die Pipe von allen Schreibern geschlossen wurde und - * die letzte Seite angesprochen wird, bekommt der Prozess - * ein SIGPIPE gesendet. */ - if (NPIPE_WSTART(*inode) == (NPIPE_WSTART(*inode) & PAGE_MASK)) { - if (idx < pidx - 1) - return 1; - - if (idx == pidx -1) { - pm_sigpipe(pmp); - return 1; - } - pm_sigpipe(pmp); - return (unsigned long) get_free_page(GFP_USER); - } - - /* Aktueller Zugriff nicht auf letzter Seite (extern auch geprueft) - * Der Fall wo kein Schreiber mehr vorhanden ist und der Zugriff - * hinter der letzten Seite erfolgt, wird in pipemap_nopage durch - * pipe_end() erfasst ... */ - - if (pidx != idx) - return 0; - - /* Startadresse fuer die Initialisierung ermitteln */ - init_pos = (char *)pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[pidx])); - /* Keine Page vorhanden */ - if (init_pos == NULL) - return 0; - - len = NPIPE_WSTART(*inode) & ~PAGE_MASK; - init_pos += len; - len = PAGE_SIZE - len; - - /* Initialisierung des Restes mit 0 */ - memset((void *) init_pos, 0, len); - - /* Da die Pipe von allen Schreibern geschlossen wurde, bekommt der - * Prozess ein SIGPIPE ... */ - pm_sigpipe(pmp); - return 1; -} - - -static void pipe_reset(char * str, struct inode *inode) { - - if (!PIPE_WRITERS(*inode) && PIPE_READERS(*inode) && - PIPE_LEN(*inode) && PIPE_MODE(*inode) != NORM_PIPE) { - wait_backswitch (inode, FMODE_READ); - wake_up_interruptible(&PIPE_WAIT(*inode)); - return; - } - - if (PIPE_READERS(*inode) || PIPE_WRITERS(*inode)) return; - - NPIPE_START(*inode) = MPIPE_BASE(*inode); - NPIPE_WSTART(*inode) = NPIPE_START(*inode); - MPIPE_START(*inode) = 0; - PIPE_LEN(*inode) = 0; - - if(__HIGH(*inode)) - printk("[%d] pipe reset vals done\n",CPID); - - if (PIPE_MODE(*inode) == NORM_PIPE) return; - - if(__HIGH(*inode)) - printk("[%d] pipe_reset calls backswitch ...\n",CPID); - - wait_backswitch (inode, FMODE_READ); - - return; -} - -/* pipe_end : Bei der normalen Pipe bekommt ein Leser oder Schreiber beim - * Beenden der letzten Gegenseite das Ende mittels SIGPIPE mitgeteilt. - * Dieses Verhalten muss auch fuer die eingeblendete Pipe nachgebildet - * werden. Dazu muss in pipemap_nopage() vor bzw. nach dem Warten geprueft - * werden ob noch ein Partner vorhanden ist. Dabei muessen diverse Sonder- - * faelle beruecksichtigt werden. - * Im Fall wo der map-Leser durch den letzten Schreiber ueber das Pipe-ende - * durch SIGPIPE informiert wird, kann dieser ev. restlich vorhandene - * Inhalte noch durch ein read() auslesen (Werte ueber ioctl() erfragen). - */ - -static int pipe_end(struct inode *inode, int mode) { - - - /* Jemand hat gerade etwas mit der Pipe vor; das koennte die - * Situation noch veraendern; daher Abwarten. */ - if (PIPE_LOCK(*inode)) return 0; - - /* Schreib-Pipe */ - if (mode == VM_WR_PIPE) { - /* Es gibt lesende Prozesse -> OK */ - if (PIPE_READERS(*inode)) return 0; - return 1; /* SIGPIPE senden ... */ - } - - /* Lese-Pipe */ - /* Es gibt schreibende Prozesse -> OK */ - if (PIPE_WRITERS(*inode)) return 0; - - return 1; /* SIGPIPE senden ... */ -} - -/* Damit kann die Funktion auch von den urspruenglichen release-Funktionen - * aufgerufen werden. - */ - -static void do_pclose (struct inode * inode, int mode) { - - /* Zuerst alle wecken um ev. ein Beenden zu ermoeglichen. */ - - wake_up_interruptible(&PIPE_WAIT(*inode)); - pipe_reset("do_pclose", inode); - - return; -} - /* We don't use the head/tail construction any more. Now we use the start/len*/ /* construction providing full use of PIPE_BUF (multiple of PAGE_SIZE) */ @@ -684,357 +26,104 @@ /* Additionally, we now use locking technique. This prevents race condition */ /* in case of paging and multiple read/write on the same pipe. (FGC) */ -/** Pipe-Lesefunktion : Verbesserung durch Verwendung der Start, Laengen - ** Definition des Aktuellen Bereiches. Dadurch kann PIPE_BUF voll ge- - ** nutzt werden. PIPE_BUF ist prinzipiell ein ganzzahlig Vielfaches der - ** Speicherseiten-Groesse. Zur Zeit ist dieser Faktor aber mit 1 festgelegt. - ** Es wird ein Locking-Mechanismus verwendet, der gleichzeitiges Lesen und - ** Schreiben und die daraus resultierenden Probleme verhindert. - **/ - -/* Syro : new : pipe_read : Auf der Basis der orignal pipe_read()-Funktion - * die geloescht wurde. -*/ static int pipe_read(struct inode * inode, struct file * filp, char * buf, int count) { int chars = 0, size = 0, read = 0; char *pipebuf; - - /* Backswitch soll auch bei einem Lesezugriff ausgeloest werden. */ - if (PIPE_MODE(*inode) == MTON_PIPE) - wait_backswitch(inode, FMODE_READ); - if (filp->f_flags & O_NONBLOCK) { - if (PIPE_LOCK(*inode)) /* Pipe gelocked -> nochmals */ + if (PIPE_LOCK(*inode)) return -EAGAIN; - if (PIPE_EMPTY(*inode)) /* Leer : Wenns Schreiber gibt, */ - if (PIPE_WRITERS(*inode)) /* dann nochmals bis sie */ - return -EAGAIN; /* was geschrieben haben */ - else /* keine Schreiber : es gibt nichts zu lesen */ + if (PIPE_EMPTY(*inode)) + if (PIPE_WRITERS(*inode)) + return -EAGAIN; + else + return 0; + } else while (PIPE_EMPTY(*inode) || PIPE_LOCK(*inode)) { + if (PIPE_EMPTY(*inode)) { + if (!PIPE_WRITERS(*inode)) return 0; - } - else while (PIPE_EMPTY(*inode) || PIPE_LOCK(*inode) || - wait_backswitch(inode, FMODE_READ)) { - /* Warten bis die Pipe freigegeben ist oder etwas drinnen ist */ - if (PIPE_EMPTY(*inode)) { /* Wenn sie leer ist und niemand */ - /* etwas schreiben wird (und tatsaechlich leer !) */ - if (!PIPE_WRITERS(*inode) && !PIPE_LEN(*inode)) - return 0; /* dann gibts nichts zu lesen. */ } - /* Taucht ein Signal auf, das nicht blockiert ist, dann wird - * der Aufruf mit ERESTARTSYS beendet. (System-Call nochmals - * starten ... ) */ if (current->signal & ~current->blocked) - return -ERESTARTSYS; - if (PIPE_WRITERS(*inode)){ - wake_up_interruptible(&PIPE_WAIT(*inode)); - } + return -ERESTARTSYS; interruptible_sleep_on(&PIPE_WAIT(*inode)); } - /* Dem Lesen steht nichts mehr im Wege ... */ - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - /* Es sollen count Bytes nach buf gelesen werden. - * Dazu wird solange gelesen bis count Bytes gelesen wurden oder - * die Pipe leer ist (size == 0). - * Die Schleife ist notwendig, da u.U. ueber die Nahtstelle des - * Ringpuffers gelesen werden muss. Es wird zuerst bis zum Ende - * des linearen Bereiches gelesen und im naechsten Schritt vom - * Anfang weg. */ + PIPE_LOCK(*inode)++; while (count>0 && (size = PIPE_SIZE(*inode))) { - /* In chars wird die Anzahl der zu lesenden Bytes bestimmt. Zuerst - * wird die Laenge bis zum Ende ermittelt. */ - unsigned long new_pos = 0; - int shift_it = 0; /* False */ - if (PIPE_MODE(*inode) == NORM_PIPE) - chars = PIPE_MAX_RCHUNK(*inode); - else - chars = PIPE_MMAX_RCHUNK(*inode); - /* PIPE_MAX_RCHUNK liefert im Falle eines mehrseitigen Pipe- - * Buffers nur den Wert innerhalb einer Seite. Die Schleife - * wird also entsprechend der Seitenanzahl durchlaufen. */ + chars = PIPE_MAX_RCHUNK(*inode); if (chars > count) chars = count; - /* Wenn chars groesser als der Pipe-Inhalt ist, kann - * natuerlich nur diese Anzahl an Bytes geliefert werden; - * daher wird chars auf size gesetzt (unabhaengig ob ueber - * die Nahtstelle gelesen wird). */ if (chars > size) chars = size; - /* In read wird die Anzahl der gelesenen Bytes mitgezaehlt; - * der Wert wird am Ende als Return-Wert gebraucht. */ read += chars; - - /* Liefert eine Zeiger auf die aktuelle Schreib- - * position in der entsprechenden Seite des Buffers. - * Die Abfrage auf PIPE_FREE zuvor faengt eine - * moegliche Bufferueberschreitung ab. */ - - pipebuf = get_pos_baddr(inode, NPIPE_START(*inode), - FMODE_READ); - - if (! pipebuf) { - printk("[%d] READ : no read address -> SIGPIPE\n",CPID); - PIPE_LOCK(*inode)--; - send_sig(SIGPIPE,current,0); - wake_up_interruptible(&PIPE_WAIT(*inode)); - return read? :-EPIPE; - } - - - /* Anpassen des aktuellen Bereiches durch das Nachziehen - * des Startpunktes unter Beruecksichtigung eines - * End-Start-Sprunges und anpassen des Laengenwertes. */ - /* Beruecksichtigung des aktuellen Pipe-Modes. Wenn es Lese- - * Einblendungen der Pipe gibt, dann wird nur der fuer den - * read()-Zugriff zustaendige Wert NPIPE_START angepasst; - * ausser wenn der einzige Lese-Mapper seinen Start durch ein - * unmap ueber NPIPE_START gezogen hat !! In diesem Fall muss - * auch eine buf_shift erfolgen. */ - if (PIPE_MODE(*inode) != NORM_PIPE && - mapcnt(MPIPE_READERS(*inode)) && - ! (mapcnt(MPIPE_READERS(*inode)) == 1 && - NPIPE_START(*inode) < PM_POS(MPIPE_READERS(*inode)))) { - - /* Hier erfolgt die Aenderung des RDWR-Buffers nicht - * durch PIPE_LEN sondern durch NPIPE_START (daraus - * wird PIPE_SIZE berechnet) */ - NPIPE_START(*inode) += chars; - } - else { /* Ist die Pipe nicht eingeblendet (entweder Norm-Mode - * oder keine Leseeinblendung vorhanden), dann muss auch - * ein sync/commit erfolgen, wobei bei der Pipe im Map- - * Mode eine Bufferanpassung erfolgen muss (buf_shift()) - * unmap-bedingte Verschiebung darf aber nicht vom RDWR-Wert - * ueberrollt werden !! (nval-Sache) - */ - if (PIPE_MODE(*inode) != NORM_PIPE) { - unsigned long nval = chars; - if (mapcnt(MPIPE_READERS(*inode)) == 1 && - NPIPE_START(*inode) < - PM_POS(MPIPE_READERS(*inode))) - nval = (NPIPE_START(*inode)+chars < - PM_POS(MPIPE_READERS(*inode))?chars: - PM_POS(MPIPE_READERS(*inode))- - NPIPE_START(*inode)); - shift_it = 1; - new_pos = NPIPE_START(*inode)+nval; - NPIPE_START(*inode) += chars; - /* Laenge wird in buf_shift() nicht veraendert, muss - * aber erfolgen, da hier sehr wohl der ganze Buffer - * betroffen ist (nicht nur die RDWR-Sicht). */ - PIPE_LEN(*inode) -= nval; - } - else { /* Pipe im Normalmodus */ - PIPE_START(*inode) += chars; - PIPE_START(*inode) &= - (PIPE_BUF_SIZE(*inode)-1); - NPIPE_START(*inode) = PIPE_START(*inode); - PIPE_LEN(*inode) -= chars; - } - } + pipebuf = PIPE_BASE(*inode)+PIPE_START(*inode); + PIPE_START(*inode) += chars; + PIPE_START(*inode) &= (PIPE_BUF-1); + PIPE_LEN(*inode) -= chars; count -= chars; - memcpy_tofs(buf, pipebuf, chars ); + memcpy_tofs(buf, pipebuf, chars ); buf += chars; - if (shift_it){ - buf_shift (inode, new_pos, VM_RD_PIPE); - shift_it = new_pos = 0; - flush_tlb_mm(current->mm); - } } - /* Freigabe der Pipe nach dem vollstaendigen Lesevorgang. */ PIPE_LOCK(*inode)--; - - /* Auch nach dem Lesen auf Ruecksetzen testen .... */ - if (PIPE_MODE(*inode) == MTON_PIPE) - wait_backswitch(inode, FMODE_READ); - - /* Aktivierung der auf dieser Pipe wartenden Prozesse .. */ wake_up_interruptible(&PIPE_WAIT(*inode)); - - if (read) { /* Nachdem gelesen wurde, Aenderungszeit aktualisieren */ + if (read) { UPDATE_ATIME(inode); - return read; /* Ausstieg in Normalfall ... */ + return read; } - /* Wenn nichts gelesen wurde aber Prozesse schreibend mit der Pipe - * verbunden sind, ist damit zu rechnen, dass bald etwas in die - * Pipe geschrieben wird; deshalb wird mit Returnwert EAGAIN zu - * einem nochmaligen Aufruf der Funktion aufgefordert ... */ - - if (PIPE_WRITERS(*inode)) + if (PIPE_WRITERS(*inode)) return -EAGAIN; - return 0; /* Ansonst wurde eben nichts gelesen (0) */ + return 0; } - - -/* - * Pipe-Schreibfunktion : - * Es sollen count Bytes von der Adresse buf im Usersegment in die - * Pipe geschrieben werden. Dabei muss ein Schreibvorgang von - * bis zu PIPE_BUF Bytes atomar (also ohne Unterbrechung durch einen - * anderen Pipe-Schreib-Prozess) erfolgen. Eventuell muss aber - * gewartet werden bis genug Platz in der Pipe ist (bzw. bis sie - * freigegeben wird - PIPE_LOCK). Dazu ist die 1. Innere While- - * Schleife da. Sollen mehr Bytes geschrieben werden, muss ein - * Warten auf Auslesen der Pipe eingeplant werden. Diese beliebig - * oft notwendige Wiederholung wird durch die aeussere While-Schleife - * erreicht. Auf alle Faelle wird einmal geschrieben was moeglich - * ist (free=1). - * In der 2. inneren Schleife erfolgt das eigentlich Schreiben; wobei - * die Iteration wegen dem ev. noetigen Ueberwinden der Nahtstelle des Ring- - * Puffers gebraucht wird; zuerst wird bis zum Ende des Puffers - * geschrieben und dann vom Anfang bis max. zum Startpunkt des - * aktuellen Bereiches. - * UNKLARHEIT : Am Ende werden Zeiten modifiziert; warum i_ctime ?? - */ - - -/* pipe_write : Auf Basis der original pipe_write-Funktion die geloescht - * wurde. - * Ein Aufruf von buf_shift ist in der write-Funktion nicht noetig, da beim - * Beschreiben des Buffers durch write keine Seiten uebersprungen werden - * koennen. - */ - + static int pipe_write(struct inode * inode, struct file * filp, const char * buf, int count) { int chars = 0, free = 0, written = 0; char *pipebuf; - /* Schreibversuch ohne lesende Prozesse an der Pipe hat eine Fehler - * zur Folge. Der schreibende Prozess erhaelt das Signal SIGPIPE - * (send_sig) und die Fehlernummer EPIPE wird gesetzt. - * (unabhaengig ob das O_NONBLOCK-Flag gesetzt ist oder nicht. - */ - - if (! PIPE_READERS(*inode)) { /* no readers */ - printk("[%d] WRITE : no readers -> SIGPIPE\n",CPID); + if (!PIPE_READERS(*inode)) { /* no readers */ send_sig(SIGPIPE,current,0); return -EPIPE; } - - if (atomic_op(inode, count, NPIPE_WSTART(*inode))) +/* if count <= PIPE_BUF, we have to make it atomic */ + if (count <= PIPE_BUF) free = count; else free = 1; /* can't do it atomically, wait for any free space */ - while (count>0) { - /* Schleife fuer Anforderung Atomares Schreiben, bzw. wenn die - * Pipe gesperrt ist. */ - while ((PIPE_FREE(*inode) < free) || PIPE_LOCK(*inode) || - wait_backswitch(inode, FMODE_WRITE) || - (PIPE_WAIT(*inode) == NULL)) { - /* Schreiben wird abgebrochen wenn keine Lese-Prozesse - * mehr vorhanden sind. Schreiber erhaelt SIGPIPE Signal - * mit entweder EPIPE als Fehlernummer oder der Anzahl der - * geschriebenen Bytes. */ + while ((PIPE_FREE(*inode) < free) || PIPE_LOCK(*inode)) { if (!PIPE_READERS(*inode)) { /* no readers */ - printk("[%d] WRITE : no readers -> SIGPIPE\n", - CPID); send_sig(SIGPIPE,current,0); return written? :-EPIPE; } - /* Wenn fuer den Prozess ein Signal anstht, das - * nicht ausmaskiert ist, wird der Aufruf auch - * abgebrochen. Returnwert ist entweder die Anzahl der - * bisher geschriebenen Bytes oder die Fehlernummer - * ERESTARTSYS. **/ if (current->signal & ~current->blocked) - return written? :-ERESTARTSYS; - /* Ist nichtblockierendes Verhalten erwuenscht (nur - * bei FIFOs moeglich) wird hier der Aufruf entweder - * mit der Anzahl der gelesenen Bytes oder mit der - * Fehlernummer EAGAIN beendet. **/ + return written? :-ERESTARTSYS; if (filp->f_flags & O_NONBLOCK) return written? :-EAGAIN; - /* Warten bis eine Leseoperation auf der - * Pipe ausgefuehrt wurde. **/ interruptible_sleep_on(&PIPE_WAIT(*inode)); } - /** Durchfuehren einer atomaren Schreiboperation. Die Schleife - ** wird fuer einen eventuell durchzufuehrenden Puffer-Naht- - ** Sprung gebraucht. Zuerst bis zum Pufferende und dann bis - ** vom Anfang weg schreiben. **/ - PIPE_LOCK(*inode)++; /** Exklusiven Zugriff sichern. **/ - /** Solange etwas zu schreiben ist und solange Platz ist.. **/ + PIPE_LOCK(*inode)++; while (count>0 && (free = PIPE_FREE(*inode))) { - /* Platz bis zur Puffernaht bzw bis zur Seitengrenze - * bestimmen; mehr kann auf einmal nicht geschrieben werden, - * da im Falle von mehreren Seiten erst die neue Basis- - * adresse bestimmt werden muss (get_pos_baddr()); - * darueberhinaus kann vorher noch das Ende des Schreib - * bereiches liegen (Ringbuffer). */ - if (PIPE_MODE(*inode) == NORM_PIPE) - chars = PIPE_MAX_WCHUNK(*inode); - else - chars = PIPE_MMAX_WCHUNK(*inode); - /* Wenn der Bedarf nicht groesser ist, ist kein Naht- - * sprung noetig. chars kann angepasst werden. */ + chars = PIPE_MAX_WCHUNK(*inode); if (chars > count) chars = count; - /* free < chars : nur bei Nichtatomar. */ if (chars > free) chars = free; - /* Liefert einen Zeiger auf die aktuelle Schreib- - * position in der entsprechenden Seite des Buffers. - * Die Abfrage auf PIPE_FREE zuvor faengt eine - * moegliche Bufferueberschreitung ab. */ - - pipebuf = get_pos_baddr(inode, NPIPE_WSTART(*inode), - FMODE_WRITE); - - if (! pipebuf) { - PIPE_LOCK(*inode)--; - printk("[%d] WRITE no write-address -> SIGPIPE\n",CPID); - send_sig(SIGPIPE,current,0); - wake_up_interruptible(&PIPE_WAIT(*inode)); - return written? :-EPIPE; - } + pipebuf = PIPE_BASE(*inode)+PIPE_END(*inode); written += chars; - - /* Wenn die Pipe im Normalmodus ist, oder wenn nur - * mit write() auf sie zugegriffen wird, dann muss - * sofort ein commit/sync erfolgen. Genauso wenn bei - * nur einem Mapper dieser durch unmap seine Schreib- - * position ueber NPIPE_WSTART gezogen hat. */ - if (PIPE_MODE(*inode) == NORM_PIPE || - ! mapcnt(MPIPE_WRITERS(*inode))) - PIPE_LEN(*inode) += chars; - else if (mapcnt(MPIPE_WRITERS(*inode)) == 1 && - NPIPE_WSTART(*inode) < PM_POS(MPIPE_WRITERS(*inode))) - PIPE_LEN(*inode) += ((NPIPE_WSTART(*inode)+chars) - < PM_POS(MPIPE_WRITERS(*inode)) - ? chars - :(PM_POS(MPIPE_WRITERS(*inode))-NPIPE_WSTART(*inode))); - NPIPE_WSTART(*inode) += chars; - /* Bei der Normal-Pipe darf der Wert nicht ueber die - * Seitengrenze hinaus gehen.... */ - if (PIPE_MODE(*inode) == NORM_PIPE) - NPIPE_WSTART(*inode) &= ~PAGE_MASK; + PIPE_LEN(*inode) += chars; count -= chars; - /* Durchfuehren der Schreiboperation . */ memcpy_fromfs(pipebuf, buf, chars ); buf += chars; - flush_tlb_mm(current->mm); } - PIPE_LOCK(*inode)--; /* Pipe freigeben .. */ - /* Aktiviern der auf der Pipe wartenden Prozesse um ein - * Auslesen der Pipe zu ermoeglichen. */ + PIPE_LOCK(*inode)--; wake_up_interruptible(&PIPE_WAIT(*inode)); free = 1; - } /* Bei atomaren Operationen wird diese Schleife sofort verlassen. */ - /* Anpassen der Zeitstempel (sollte es hier nicht eher i_atime - * (letzter Zugriff) anstelle von i_ctime (Erzeugung) heissen ? */ - inode->i_atime = inode->i_mtime = CURRENT_TIME; - + } + inode->i_ctime = inode->i_mtime = CURRENT_TIME; return written; } - -/** Ein lseek in einem sequentiellen Datenstrom ist nicht moeglich; es wird - ** immer ein Fehler geliefert. - **/ static int pipe_lseek(struct inode * inode, struct file * file, off_t offset, int orig) { return -ESPIPE; @@ -1050,271 +139,36 @@ return -EBADF; } -/* - * Der Aufruf dieser Funktion erfolgt erst nachdem das VFS eine - * Vorauswertung der Argumente durchgefuehrt hat. Die Kommandos - * FIONCLEX, FIOCLEX, FIONBIO und FIOASYNC werden dabei schon durch - * das VFS behandelt. - * Lediglich FIONREAD (schreibt die Anzahl der noch nicht gelesenen Bytes - * in der Pipe an die Adresse arg) wird durch die spezifische Funktion - * behandelt. - * Alle anderen cmd Werte haben einen Fehler zur Folge. - * Neue Kommandos fuer die Behandlung der eingeblendeten Pipe. - * Aenderung bei FIONREAD bei mmaped-Pipes : solange die Pipe im map-Modus - * ist, wird die Anzahl der Bytes die tatsaechlich ausgelesen werden - * koennen geliefert. Will man mehr und genauere Informationen, so muss man - * das Kommando PM_GETSTAT verwenden. - */ static int pipe_ioctl(struct inode *pino, struct file * filp, unsigned int cmd, unsigned long arg) { - int error = 0; + int error; switch (cmd) { - case PM_DIAG: { - /* Ausgabe von Diagnose-Infos */ - struct vm_area_struct * vma; - unsigned long addr; - - rwvals("IOCTL Diag :", pino); - rwcnts("IOCTL Diag :", pino); - pkmapper(MPIPE_READERS(*pino)); - pkmapper(MPIPE_WRITERS(*pino)); - qlen(pino); - error = verify_area(VERIFY_READ, (void *) arg, - sizeof(unsigned long)); - if (error) return error; - - addr = get_user((unsigned long *)arg); - if (!addr) return error; - - vma = find_vma(current->mm, addr); - if (!vma || vma->vm_start > addr || - vma->vm_inode != pino || ! VMA_PMAP(vma)) { - if (__LOW(*pino)) - printk("ioctl-diag : wrong address 0x%lx\n",addr); - return -EINVAL; - } - printk("pmap-entry :\n"); - pkm(VMA_PMAP(vma)); - return error; - } case FIONREAD: - /* Ist der durch arg angegebene Speicher auch gueltig .. */ error = verify_area(VERIFY_WRITE, (void *) arg, sizeof(int)); if (!error) - /* Daten ins User-Segment schreiben .... */ put_user(PIPE_SIZE(*pino),(int *) arg); return error; - case PM_PMODE: - /* Der Modus in dem sich die Pipe befindet wird ausgelesen. - * Liefert entweder NORM_PIPE oder MAP_PIPE. Diese Werte - * sind in include/linux/pipe_fs_i.h definiert und werden - * ueber mmap.h dem Anwender zur Verfuegung gestellt. */ - /* Ist der durch arg angegebene Speicher auch gueltig .. */ - error = verify_area(VERIFY_WRITE, (void *) arg, sizeof(char)); - if (!error) { - char mode = PIPE_MODE(*pino); - if (mode != NORM_PIPE) mode = MAP_PIPE; - /** Daten ins User-Segment schreiben .... **/ - put_user(PIPE_MODE(*pino),(char *) arg); - } - return error; - case PM_BUFOFF: - /* Liefert den aktuellen Offset im Pipe-Buffer. Ob der read - * oder write-Offset geliefert wird, haengt davon ab, welcher - * File-Deskriptor beim ioctl()-Call angegeben wurde. - * Der Anwender braucht diesen Wert, da er ihn im mmap() - * als offset angeben muss. */ - error = verify_area(VERIFY_WRITE, (void *) arg, sizeof(unsigned long)); - if (error) return error; - /** Daten ins User-Segment schreiben .... **/ - if (PIPE_MODE(*pino) == NORM_PIPE){ - if (filp->f_mode == FMODE_WRITE) - put_user(PIPE_WOFF(*pino), - (unsigned long *) arg); - else - put_user(PIPE_ROFF(*pino), - (unsigned long *) arg); - } - else { - if (filp->f_mode == FMODE_WRITE) - put_user(MPIPE_WOFF(*pino), - (unsigned long *) arg); - else - put_user(MPIPE_ROFF(*pino), - (unsigned long *) arg); - } - return error; - case PM_GETSTAT: { - /* Liefert einige aktuelle Werte zu der angegebenen Pipe. - * Die Identifizierung der Pipe erfolgt ueber den angegebenen - * Filedeskriptor. Dieser wird auch, wenn noetig, zur Unter- - * scheidung zwischen Lese-/Schreib-Pipe verwendet. - * Fuer die Ermittlung der Einblendungs-spezifischen Werte - * wird der Wert von addr verwendet. Dieser Wert muss eine - * Adresse innerhalb der gewuenschten Einblendung sein. - * Je nach den Eingangswerten, werden die entsprechenden - * Status-Werte ermittelt. Werte dieaufgrund der Eingaben - * nicht festgelegt werden koennen, werden mit Unguelltig/0 - * retouniert. */ - struct vm_area_struct * vma; - unsigned long addr,sbuf,tbuf; - int flag; - - error = verify_area(VERIFY_READ, - &((struct pstat_struct *)arg)->addr, - sizeof(unsigned long)); - if (error) return error; - error = verify_area(VERIFY_WRITE, - (struct pstat_struct *)arg, - sizeof(struct pstat_struct)); - if (error) return error; - - put_user(PIPE_MODE(*pino), - &((struct pstat_struct *)arg)->mode); - put_user(PIPE_READERS(*pino), - &((struct pstat_struct *)arg)->readers); - put_user(PIPE_WRITERS(*pino), - &((struct pstat_struct *)arg)->writers); - put_user(PIPE_LEN(*pino), - &((struct pstat_struct *)arg)->bsize); - put_user((unsigned long) 0, - &((struct pstat_struct *)arg)->updsize); - put_user((unsigned long) 0, - &((struct pstat_struct *)arg)->sec_rbuf); - put_user((unsigned long) 0, - &((struct pstat_struct *)arg)->tot_rbuf); - put_user((int) 0, - &((struct pstat_struct *)arg)->sigflag); - - /* Normale Pipe -> keine weiteren Werte ... */ - if (PIPE_MODE(*pino) == NORM_PIPE) return error; - - addr = get_user(&((struct pstat_struct *) arg)->addr); - /* Mehr Werte nur mit Angabe einer Adresse. */ - if (!addr) { - return error; - } - vma = find_vma(current->mm, addr); - if (!vma || vma->vm_start > addr || - vma->vm_end < addr || - vma->vm_inode != pino || ! VMA_PMAP(vma)) - { - return -EINVAL; - } - put_user(PM_AUTO(VMA_PMAP(vma)), - &((struct pstat_struct *) arg)->updsize); - - put_user(PM_START(VMA_PMAP(vma)), - &((struct pstat_struct *) arg)->vmstart); - - put_user(PM_POS(VMA_PMAP(vma)), - &((struct pstat_struct *) arg)->io_pos); - - flag = ((PM_FLAG(VMA_PMAP(vma))) & PM_SIG_MASK); - put_user(flag, - &((struct pstat_struct *) arg)->sigflag); - - /* Keine read-Buffer Werte fuer Write-Pipe. */ - if (filp->f_mode == FMODE_WRITE) return error; - - tbuf = MPIPE_WOFF(*pino) - - PM_ADDR(VMA_PMAP(vma), VMA_OFF(vma, addr)); - - sbuf = (MPIPE_WOFF(*pino) & PAGE_MASK) - - PM_ADDR(VMA_PMAP(vma), VMA_OFF(vma, addr)); - /* Adresse war unsinnig. */ - - if (tbuf > PIPE_LEN(*pino)) - { -/* return -EINVAL; */ tbuf = 0; - } - if (sbuf > PIPE_LEN(*pino)) - { -/* return -EINVAL; */ sbuf = 0; - } - - put_user(tbuf, - &((struct pstat_struct *)arg)->tot_rbuf); - put_user(sbuf, - &((struct pstat_struct *)arg)->sec_rbuf); - - return error; - } - case PM_SETUPDSIZE: { - /* Setzt den aktuellen auto-commit-Wert fuer die angegebene - * Pipe-Einblendung. Die benoetigten Werte werden in Form - * einer Struktur uebergeben. Diese besteht aus zwei - * unsigned long Werten, der Anfangsadresse des betreffenden - * VMAs und dem neuen Wert fuer das auto-commit. */ - struct vm_area_struct * vma; - unsigned long addr; - int asize; - - error = verify_area(VERIFY_READ, (void *) arg, - sizeof(struct pstat_struct)); - if (error) return error; - - addr = get_user(&((struct pstat_struct *) arg)->addr); - if (!addr) return -EINVAL; - - vma = find_vma(current->mm, addr); - if (!vma || vma->vm_start > addr || - vma->vm_inode != pino || ! VMA_PMAP(vma)) - return -EINVAL; - asize = get_user(&((struct pstat_struct *) \ - arg)->updsize); - if (asize > PIPE_BUF_SIZE(*pino)/2) return -EINVAL; - PM_AUTO(VMA_PMAP(vma)) = PAGE_ALIGN(asize); - return error; - } - case PM_DLEV: - error = verify_area(VERIFY_READ,(void *)arg, - sizeof(int)); - if (!error) { - PIPE_DLEV(*pino) = get_user((int *) arg); - if (__LOW(*pino)) - printk("[%d] ioctl : Set diag-level to %d\n",CPID,PIPE_DLEV(*pino)); - } - return error; - default: /** Ungueltiges Kommando ... **/ + default: return -EINVAL; } } -/* - * Select soll anzeigen ob von der Datei gelesen, ob in sie geschrieben - * werden kann oder ob eine Ausnahmebedingung vorliegt. - * An sich sollte das Verhalten von Pipes und FIFOs gleich sein; bei SunOS - * besteht allerdings ein Unterschied bei der Lesbarkeit. Um dieses SunOS- - * konforme Verhalten auch zur verfuegung zu stellen, gibt es hier - * getrennte Funktionen fuer Select auf Pipes und FIFOs. - * Retourniert wird die Anzahl der bereiten Deskriptoren - hier also maximal - * 1 - oder, wenn der select_wait() Aufruf durch einen Timeout beendet - * wurde, dann der Wert 0. - */ - static int pipe_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait) { switch (sel_type) { - case SEL_IN: - /** Pipe ist lesebereit wenn sie nicht leer ist oder - ** wenn sie nicht gerade schreibend zugegriffen wird. **/ + case SEL_IN: if (!PIPE_EMPTY(*inode) || !PIPE_WRITERS(*inode)) return 1; select_wait(&PIPE_WAIT(*inode), wait); return 0; case SEL_OUT: - /** Pipe ist schreibbereit wenn sie leer ist oder - ** wenn sie nicht gerade lesend zugreifen wird. **/ if (PIPE_EMPTY(*inode) || !PIPE_READERS(*inode)) return 1; select_wait(&PIPE_WAIT(*inode), wait); return 0; case SEL_EX: - /** Eine Ausnahmebedingung ist gegeben, wenn es keine - ** lesenden oder schreibenden Prozesse gibt. **/ if (!PIPE_READERS(*inode) || !PIPE_WRITERS(*inode)) return 1; select_wait(&inode->i_wait,wait); @@ -1359,16 +213,6 @@ * The 'connect_xxx()' functions are needed for named pipes when * the open() code hasn't guaranteed a connection (O_NONBLOCK), * and we need to act differently until we do get a writer.. - ** Die connect_xxx() Funktionen werden nach dem oeffnen einer - ** Readonly-FIFO im nonblock-Modus gebraucht. Laut POSIX.1 kehrt open() - ** unabhaengig davon ob schreibende Prozesse vorhanden sind mit der - ** geoeffneten named Pipe zurueck. - ** - ** Die connect_read()-Funktion fuehrt eine Pruefung auf schreibende Prozesse - ** durch. Sobald das einmal durchgefuehrt wurde, kann das Lesen zukuenftig - ** von der Standard-FIFO-Lesefunktion in read_fifo_fops durchgefuehrt werden. - ** Dementsprechend wird eine Neubelegung des File-Operationsvektors durchge- - ** fuehrt (read_fifo_fops). */ static int connect_read(struct inode * inode, struct file * filp, char * buf, int count) { @@ -1378,13 +222,6 @@ return pipe_read(inode,filp,buf,count); } -/** Nachdem der Deskriptor einer O_NONBLOCK FIFO auch einem select()-Aufruf - ** uebergeben werden kann, muss hier ebenfalls das POSIX-Verhalten der - ** Readonly-FIFO beruecksichtigt werden. Fuer SEL_IN ist ebenfalls eine - ** Ersetzung des File-Operationsvektors erforderlich. Ansonsten ist das - ** Verhalten wie bei fifo_select(). - **/ - static int connect_select(struct inode * inode, struct file * filp, int sel_type, select_table * wait) { switch (sel_type) { @@ -1412,23 +249,15 @@ return 0; } -/** Beim Freigeben des Objekts (Pipe/FIFO) ob zum Lesen, Schreiben oder - ** fuer beides zugeordnet wird der entsprechende Zaehler verringert - ** und dann die auf diesem Objekt wartenden Prozesse aktiviert, damit - ** diese ihre Arbeit fortsetzen koennen. - **/ - static void pipe_read_release(struct inode * inode, struct file * filp) { PIPE_READERS(*inode)--; - do_pclose(inode, filp->f_mode); /* Syro : new */ wake_up_interruptible(&PIPE_WAIT(*inode)); } static void pipe_write_release(struct inode * inode, struct file * filp) { PIPE_WRITERS(*inode)--; - do_pclose(inode, filp->f_mode); /* Syro : new */ wake_up_interruptible(&PIPE_WAIT(*inode)); } @@ -1438,17 +267,9 @@ PIPE_READERS(*inode)--; if (filp->f_mode & FMODE_WRITE) PIPE_WRITERS(*inode)--; - do_pclose(inode, filp->f_mode); /* Syro : new */ wake_up_interruptible(&PIPE_WAIT(*inode)); } -/** Wird beim Oeffnen dieses Objektes (FIFO/Pipe), ob zum Lesen, Schreiben - ** oder beides muss lediglich der entsprechende Zaehler der aussagt dass ein - ** Prozess dieses Objekt entsprechend zugreifft erhoeht werden. - ** Im Fall des Lese/Schreib-Zugriffs wird noch auf Uebereinstimmung mit - ** dem Modus-Flag geprueft. - **/ - static int pipe_read_open(struct inode * inode, struct file * filp) { PIPE_READERS(*inode)++; @@ -1470,1758 +291,61 @@ return 0; } - -/* Diagnose ... +/* + * The file_operations structs are not static because they + * are also used in linux/fs/fifo.c to do operations on fifo's. */ +struct file_operations connecting_fifo_fops = { + pipe_lseek, + connect_read, + bad_pipe_w, + NULL, /* no readdir */ + connect_select, + pipe_ioctl, + NULL, /* no mmap on pipes.. surprise */ + pipe_read_open, + pipe_read_release, + NULL +}; -#define PROFF(x, i) (x - MPIPE_BASE(*i)) +struct file_operations read_fifo_fops = { + pipe_lseek, + pipe_read, + bad_pipe_w, + NULL, /* no readdir */ + fifo_select, + pipe_ioctl, + NULL, /* no mmap on pipes.. surprise */ + pipe_read_open, + pipe_read_release, + NULL +}; -static void rwcnts(char * str, struct inode * inode) { - printk("[%d] %s :\n", CPID, str); - printk(" PIPE_MODE : %d\n", PIPE_MODE(*inode)); - printk(" PIPE_READERS : %d\n", PIPE_READERS(*inode)); - printk(" PIPE_WRITERS : %d\n", PIPE_WRITERS(*inode)); - printk(" READ-mapper : %d\n", mapcnt(MPIPE_READERS(*inode))); - printk(" WRITE-mapper : %d\n", mapcnt(MPIPE_WRITERS(*inode))); - return; -} +struct file_operations write_fifo_fops = { + pipe_lseek, + bad_pipe_r, + pipe_write, + NULL, /* no readdir */ + fifo_select, + pipe_ioctl, + NULL, /* mmap */ + pipe_write_open, + pipe_write_release, + NULL +}; - -static void rwvals(char * str, struct inode * inode) { - printk("[%d] %s :\n", CPID, str); - printk(" MPIPE_BASE : 0x%lx\n", MPIPE_BASE(*inode)); - printk(" R MPIPE_START : 0x%lx [%d]\n", -MPIPE_START(*inode), PM_PTEIDX(MPIPE_START(*inode))); - printk(" A NPIPE_START : 0x%lx [%d] (0x%lx [%d])\n", -NPIPE_START(*inode), PM_PTEIDX(NPIPE_START(*inode)), -PROFF(NPIPE_START(*inode),inode), PM_PTEIDX(PROFF(NPIPE_START(*inode),inode))); - printk(" R MPIPE_WSTART: 0x%lx [%d]\n", -MPIPE_WSTART(*inode), PM_PTEIDX(MPIPE_WSTART(*inode))); - printk(" A NPIPE_WSTART: 0x%lx [%d] (0x%lx [%d])\n", -NPIPE_WSTART(*inode), PM_PTEIDX(NPIPE_WSTART(*inode)), -PROFF(NPIPE_WSTART(*inode),inode), -PM_PTEIDX(PROFF(NPIPE_WSTART(*inode),inode))); - printk(" A MPIPE_ROFF : 0x%lx [%d] (0x%lx [%d])\n", -MPIPE_ROFF(*inode), PM_PTEIDX(MPIPE_ROFF(*inode)), -PROFF(MPIPE_ROFF(*inode),inode), PM_PTEIDX(PROFF(MPIPE_ROFF(*inode),inode))); - printk(" A MPIPE_WOFF : 0x%lx [%d] (0x%lx [%d])\n", -MPIPE_WOFF(*inode), PM_PTEIDX(MPIPE_WOFF(*inode)), -PROFF(MPIPE_WOFF(*inode),inode), PM_PTEIDX(PROFF(MPIPE_WOFF(*inode),inode))); - printk(" PIPE_LEN : 0x%lx\n", PIPE_LEN(*inode)); - printk(" PIPE_SIZE : 0x%lx\n", PIPE_SIZE(*inode)); - printk(" PIPE_FREE : 0x%lx\n", PIPE_FREE(*inode)); - printk(" W-CHUNK(o/n): 0x%lx (0x%lx)\n", - PIPE_MAX_WCHUNK(*inode),PIPE_MMAX_WCHUNK(*inode)); - printk(" R-CHUNK(o/n): 0x%lx (0x%lx)\n", - PIPE_MAX_RCHUNK(*inode),PIPE_MMAX_RCHUNK(*inode)); - return ; -} - - -static char * pipemode (struct vm_area_struct *vma){ - if (PM_MODE(VMA_PMAP(vma)) == VM_RD_PIPE) - return "READ-Pipe"; - if (PM_MODE(VMA_PMAP(vma)) == VM_WR_PIPE) - return "WRITE-Pipe"; - return "????-Pipe"; -} - -static void pkm(struct pipe_mapper * mapper){ - printk(" PID : %d\n",mapper->task->pid); - if (PM_MODE(mapper) == VM_RD_PIPE) - printk(" Mode : READ-Pipe\n"); - else - printk(" Mode : WRITE-Pipe\n"); - printk(" VMA-Start : 0x%lx\n",mapper->vma_start); - printk(" act_pos : 0x%lx\n",mapper->act_pos); - printk(" rel_len : 0x%lx\n",mapper->rel_len); - printk(" Flags : %lu\n",mapper->flag); - return; -} - -static void pkmapper(struct pipe_mapper * mapper){ - int i=0; - - while (mapper) { - printk("[%d] mapper-entry[%d]\n",CPID,++i); - pkm(mapper); - mapper=mapper->next; - } - return; -} - -static void pkpipe(struct inode * inode) { - printk("pipe (PID : %d) : \n",CPID); - printk("mode : %d\n",PIPE_MODE(*inode)); - printk("buf-size : %lu\n",PIPE_BUF_SIZE(*inode)); - printk("base : 0x%lx\n",(unsigned long) PIPE_BASE(*inode)); - printk("start : 0x%lx\n",(unsigned long) NPIPE_START(*inode)); - printk("len : 0x%lx\n",PIPE_LEN(*inode)); - printk("lock : %d\n",PIPE_LOCK(*inode)); - printk("rd-op : %d\n",PIPE_RD_OPENERS(*inode)); - printk("wr-op : %d\n",PIPE_WR_OPENERS(*inode)); - printk("readers : %d\n",PIPE_READERS(*inode)); - printk("writers : %d\n",PIPE_WRITERS(*inode)); - printk("map-base : 0x%lx\n",MPIPE_BASE(*inode)); - printk("map-start : 0x%lx\n",MPIPE_START(*inode)); - printk("Readers : \n"); - pkmapper(MPIPE_READERS(*inode)); - printk("Writers : \n"); - pkmapper(MPIPE_WRITERS(*inode)); - return; -} - - -static void pkbuffer(char * buf, int len) { - - char * wrp = buf + len; - printk("Buffer[%d] : \n",len); - while (buf < wrp) printk("%c",*buf++); - return; -} - - -static void pkpbpages(struct pbpage * plist, int anz) { - - int cnt; - char * page; - pte_t *pp; - - for(cnt = 0; cnt < anz; cnt++) { - pp = &(MPIPE_PTE(plist[cnt])); - if (pte_none(*pp)) - printk("[%d] %d pbp 0x%lx, page non, f %d\n",CPID,cnt,&plist[cnt],MPIPE_PFLAGS(plist[cnt])); - else if (! pte_present(*pp)) - printk("[%d] %d pbp 0x%lx, page swaped, %d\n",CPID,cnt,&plist[cnt],MPIPE_PFLAGS(plist[cnt])); - else { - page = (char *) pte_page(*pp); - printk("[%d] %d pbp 0x%lx, page 0x%lx, f %d, c %d\n",CPID,cnt,&plist[cnt],page,MPIPE_PFLAGS(plist[cnt]),mem_map[MAP_NR(page)].count); - } - } - return; -} - - -/* pte_entry() liefert zu einer Adresse den zugehoerigen Page-Table-Entry - * Es wird ein Pointer auf den entsprechenden PTE geliefert, der in den - * anderen pte_xxxx-Funktionen als Parameter verwendet werden kann. - * Sollte wohl irgendwann mal nach mm/memory.c verlegt werden, da dort viele - * der architekturunabhaengigen Page-Table-Funktionen untergebracht sind. - * Koennte fuer die SWAP-Behandlung gebraucht werden .... */ -/* -static pte_t * pte_entry(struct mm_struct * mm, unsigned long address) -{ - pgd_t * pdir_entry; - pmd_t * pmdir_entry; - - if (!(pdir_entry = pgd_offset(mm, address))) { - printk("pte_entry : No PageDir to address %lu\n", address); - return NULL; - } - if (!(pmdir_entry = pmd_offset(pdir_entry, address))) { - printk("pte_entry : No MiddlePageDir to address %lu\n", address); - return NULL; - } - return pte_offset(pmdir_entry, address); -} -*/ -/* get_pminf() : Liefert den pipe_mapper-Eintrag zu einem Prozess - * Die Identifizierung erfolgt durch Vergleich der Task-Kennung und - * der Anfangsadresse des VMAs. Dafuer muss aber eine Zusammenlegung - * des VMAs mit anderen durch merge_segments() (mm/mmap.c) verhindert - * werden. Diese Funktion wurde um eine Abfrage auf inode->i_pipe = 1 - * erweitert. Damit ist es auch moeglich, dass ein Prozess eine Pipe - * mehrfach einblendet (wozu auch immer ..) - * Lefert entweder eine Pointer auf den Mapper-Eintrag oder NULL. Wenn - * kein passender Eintrag gefunden werden kann, dann liegt ein schwerer - * Fehler vor. - */ - -static struct pipe_mapper * get_pminf(struct inode * inode, - struct task_struct * task, - unsigned long start, - int mode) { - - struct pipe_mapper * pmp = NULL; - - if (mode) /* WR_PIPE = 1 = TRUE */ - pmp = MPIPE_WRITERS(*inode); - else /* RD_PIPE = 0 = FALSE */ - pmp = MPIPE_READERS(*inode); - - while (pmp) { /* until pmp = NULL = FALSE */ - if (PM_PID(pmp) == task->pid && PM_START(pmp) == start) - return pmp; - pmp = pmp->next; - } - return pmp; -} - -/* rm_pminf : Entfernt einen Mapper-Entry aus der Mapper-Liste der Pipe. - * Ein ev. lock der Pipe muss ausserhalb erfolgen, da in der - * Funktion nicht entschieden werden kann, wie auf ev. auftretende - * Signale zu reagieren ist. (Syscall oder Speicherzugriff !!) - */ - -static void rm_pminf (struct inode * inode, - struct pipe_mapper * pminf) { - - struct pipe_mapper * pmp = NULL; - int mode; - - if (! pminf) return; - - mode = PM_MODE(pminf); - - while (PIPE_LOCK(*inode)) { /* Pipe gelocked -> nochmals */ - if (current->signal & ~current->blocked) { - break; - } - interruptible_sleep_on(&PIPE_WAIT(*inode)); - - } - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - - if (mode) { - if (pminf == MPIPE_WRITERS(*inode)) - MPIPE_WRITERS(*inode) = pminf->next; - else - pmp = MPIPE_WRITERS(*inode); - } - else { /* RD_PIPE = 0 = FALSE */ - if (pminf == MPIPE_READERS(*inode)) - MPIPE_READERS(*inode) = pminf->next; - else - pmp = MPIPE_READERS(*inode); - } - - while (pmp) { - if (pmp->next == pminf) { - pmp->next = pminf->next; - pminf->next = NULL; - pmp = pminf; - - } - pmp = pmp->next; - } - - if (mode) { - PIPE_WRITERS(*inode)--; - if (MPIPE_WRITERS(*inode) == NULL) { - PIPE_LEN(*inode) += NPIPE_WSTART(*inode) - - MPIPE_WOFF(*inode); - NPIPE_WSTART(*inode) = MPIPE_WOFF(*inode); - } - } - else { - PIPE_READERS(*inode)--; - if (MPIPE_READERS(*inode) == NULL) { - PIPE_LEN(*inode) -= NPIPE_RSTART(*inode) - - MPIPE_ROFF(*inode); - NPIPE_RSTART(*inode) = MPIPE_ROFF(*inode); - } - } - - PIPE_LOCK(*inode)--; - - kfree(pminf); - return; -} - - -/* minval :: Liefert den Minimalwert der act_pos-Komponenten aus der - * durch flag bestimmten Mapper-Liste. - * Der Wert wird als Offset in bezug auf den Ursprungsanfang der - * Pipe geliefert. - */ - -static unsigned long minval(struct inode * inode, - unsigned long cmpval, - int mode) { - - struct pipe_mapper * pmp; - - - if (mode == VM_RD_PIPE) { - pmp = MPIPE_READERS(*inode); - } - else { - pmp = MPIPE_WRITERS(*inode); - } - while (pmp) { - if (PM_POS(pmp) < cmpval) cmpval = PM_POS(pmp); - pmp = pmp->next; - } - return cmpval; -} - -/* set_pflag : Mit dieser Funktion kann der Wert des Attributs der - * Pipe-Buffer Seiten eines angegebenen Bereiches gesetzt werden. - * Wobei das Problem der oberen Grenze geloest ist (Die letzte - * Seite des Bereiches wird nur dann mit eingeschlossen, wenn der - * Endwert darin einen Offset != 0 hat). Wert wird zum aktuellen - * Wert geodert; es erfolgt keine Neusetzung. Zum Loeschen eines - * bestimmten Attributs muss das flag-Argument entsprechend - * invertiert werden. - */ - -static void set_pflag(struct inode * inode, - unsigned long pstart, - unsigned long len, - unsigned int flag) { - - unsigned int sidx, eidx, cnt; - - sidx = PM_PTEIDX(pstart - MPIPE_BASE(*inode)); - eidx = PM_PTEIDX(pstart + len - MPIPE_BASE(*inode)); - - - if (eidx > PIPE_BUF_PAGES(*inode)) - eidx = PIPE_BUF_PAGES(*inode); - - for (cnt = sidx; cnt < eidx; cnt++) { - pb_add(MPIPE_PLIST(*inode)[cnt], flag); - } - /* Wenn der Endwert tatsaechlich in der letzten Seite liegt, dann - * wird das sync-Flag gesetzt (0 - PAGE_SIZE Problem) ... */ - if ((pstart + len) & ~PAGE_MASK) { - pb_add(MPIPE_PLIST(*inode)[eidx], flag); - } - return; -} - - -/* buf_shift : Wenn durch ein read-pipe-commit der Anfang des Pipe-Buffers - * soweit verschoben wird, dass er in einer anderen als der - * ersten Seite der PTE-Liste zu liegen kommt, werden diese - * Seiten nicht mehr gebraucht und koennen freigegeben werden. - * Weiters muessen die PTEs der Liste so verschoben werden, dass - * der PTE mit dem Bufferanfang wieder am Index 0 liegt. - * Damit waechst der historische Bereich des Pipe-Buffers der - * nicht mehr zugegriffen werden kann um die Anzahl der - * entfernten Seiten an. Um weiterhin eine korrekte Umsetzung der - * Offsets und Adressen moeglich zu machen, muss der Wert - * MPIPE_BASE() auf den neuen Offset nachgezogen werden. - * Fuer die Write-Pipe wird nichts verschoben, aber es muessen - * eventuell Seiten, die nicht zugegriffen wurden ebenfalls - * initialisiert werden. Dazu wird die ZERO_PAGE verwendet, die - * in der mpipe_nopage()-Funktion abgefragt und durch eine - * leere Seite ersetzt werden muss. - */ - -static void buf_shift (struct inode * inode, unsigned long new_roff, int mode) { - - int ridx, sidx, cnt = 0, diff; - pte_t *spte, *rpte, tpte; - struct pbpage hpb, *hpbp, *spbp, *rpbp; - unsigned long size; - char *page; - - sidx = PM_PTEIDX(new_roff - MPIPE_BASE(*inode)); - if (sidx > PIPE_BUF_PAGES(*inode)) { - sidx = PIPE_BUF_PAGES(*inode); - } - - /* Write-Shift des Buffers : Leere Eintraege werden mit der ZERO-Page - * initialisiert. */ - if (mode == VM_WR_PIPE) { - ridx = PM_PTEIDX(MPIPE_WSTART(*inode)); - for (cnt = ridx; cnt < sidx; cnt++) { - if (pte_none(MPIPE_PTE(MPIPE_PLIST(*inode)[cnt]))) { - MPIPE_PTE(MPIPE_PLIST(*inode)[cnt]) = - mk_pte(ZERO_PAGE, PAGE_SHARED); - } - } - return; - } - - /* read-Pipe .... */ - - ridx = PM_PTEIDX(MPIPE_RSTART(*inode)); - if (ridx != 0) printk("[%d] buf_shift-R : ridx %d != 0 ?\n",CPID,ridx); - /* 1. Korrektur sollte ridx == sidx sein */ - MPIPE_RSTART(*inode) = new_roff - MPIPE_BASE(*inode); - - if (ridx == sidx) return; /* Bleibt in der selben Seite */ - -#define __NEW_BUF_SHIFT__ -#ifdef __NEW_BUF_SHIFT__ - - diff = sidx - ridx; - size = sizeof(struct pbpage) * diff; - - if (diff == 1) hpbp = &hpb; - else - if ((hpbp = (struct pbpage *) kmalloc(size, GFP_KERNEL)) == NULL) { - printk("[%d] buf_shift : Can't alloc kernel memory !\n",CPID); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - send_sig(SIGKILL,current,1); - return; - } - rpbp = &MPIPE_PLIST(*inode)[ridx]; - spbp = &MPIPE_PLIST(*inode)[sidx]; - - memcpy((void *) hpbp, (void *) rpbp, size); - - memcpy((void *) rpbp, (void *) spbp, - (PIPE_BUF_PAGES(*inode) * sizeof(struct pbpage)) - size); - - for (cnt = 0; cnt < diff; cnt++) { - page = (char *) pte_page(MPIPE_PTE(hpbp[cnt])); - memset((void *) page, 0, PAGE_SIZE); - pb_init(hpbp[cnt]); - } - - memcpy((void *) &(rpbp[PIPE_BUF_PAGES(*inode) - diff]), - (void *) hpbp, size); - - if (diff > 1) kfree(hpbp); - -#else - - for (cnt = 0; cnt + sidx < PIPE_BUF_PAGES(*inode); cnt++) { - rpte = &MPIPE_PTE(MPIPE_PLIST(*inode)[ridx + cnt]); - spte = &MPIPE_PTE(MPIPE_PLIST(*inode)[sidx + cnt]); - if ((cnt + ridx) < sidx) { - /* Mit free_pte() wird die Seite des PTEs korrekt - freigegeben ; auch wenn sie ausgelagert ist ! */ - if (! pte_none(*rpte)) { - page = (char *) pte_page(MPIPE_PTE( - MPIPE_PLIST(*inode)[ridx+cnt])); - if (mem_map[MAP_NR(page)].count != 1){ - mem_map[MAP_NR(page)].count = 1; - } - free_pte(*rpte); - } - } - /* Kopieren des Pipe-Buffer-List Entrys .. */ - MPIPE_PLIST(*inode)[ridx + cnt] = - MPIPE_PLIST(*inode)[sidx + cnt]; - } - for (cnt = cnt + ridx; cnt < PIPE_BUF_PAGES(*inode); cnt++){ - /* Loeschen der restlichen PTEs. */ - rpte = &MPIPE_PTE(MPIPE_PLIST(*inode)[cnt]); - if (! pte_none(*rpte)) pte_clear(rpte); - pb_init(MPIPE_PLIST(*inode)[cnt]); - } -#endif - - /* Anpassen von MPIPE_BASE und der darauf basierenden Werte. */ - flush_tlb_all(); - MPIPE_BASE(*inode) = new_roff & PAGE_MASK; - MPIPE_RSTART(*inode) = new_roff - MPIPE_BASE(*inode); - return; -} - - -/* auto_sync : Mit Hilfe dieses Wertes, kann fuer jede Einblendung angegeben - * werden, ob und wenn ja, bei welcher Groesse des bearbeiteten - * Bereiches selbsttaetig ein msync/commit erfolgen soll. - * Als Indikator wird der erste Zugriff auf eine Seite genommen. - * Dieser wird durch das Auftreten der page-exception erkannt. - * Wenn die Differenz zwischen zugegriffener Adresse und Bereichs- - * anfang (PM_START) den Wert uebersteigt, dann wird die Differenz- - * anzahl an Seiten freigegeben. Durch AUTO_STEP wird ein - * Sprungwert festgelegt. Damit wird verhindert, dass das - * auto-commit im Seitenschritt erfolgt. - */ - -static int auto_sync(struct vm_area_struct *area, - struct inode * inode, - unsigned long addr) { - - struct pipe_mapper *pminf = VMA_PMAP(area); - unsigned long bufpos = 0, vval; - - bufpos = PM_ADDR(pminf, VMA_OFF(area, addr)); - - - if (PM_MODE(pminf) == VM_RD_PIPE){ - vval = minval(inode, PM_POS(pminf), PM_MODE(pminf)); - if (((vval == PM_POS(pminf)) || - mapcnt(MPIPE_READERS(*inode)) == 1) && - (MPIPE_ROFF(*inode) != PM_POS(pminf))) - { - PIPE_LEN(*inode) -= (vval - MPIPE_ROFF(*inode)); - buf_shift(inode, vval, VM_RD_PIPE); - NPIPE_START(*inode) = MPIPE_ROFF(*inode); - } - } - - /* Kein Auto-commit. */ - if (!PM_AUTO(pminf)) return 0; - - /* Sollte eigentlich nicht vorkommen.... */ - if (bufpos < PM_POS(pminf)) - return 0; - - /* if (! pte_none(LAST_PTE(*inode)) && (bufpos > PM_POS(pminf))) {*/ - if ((MPIPE_PFLAGS(LAST_PBPAGE(*inode)) & PBF_USED) && - (bufpos > PM_POS(pminf))) { - unsigned long len; - - if ((bufpos & PAGE_MASK) <= PM_POS(pminf)) - return 0; - - len = ((bufpos & PAGE_MASK) - PM_POS(pminf)) ; - - if (PM_MODE(pminf) == VM_RD_PIPE){ - if (bufpos < (MPIPE_WOFF(*inode) & PAGE_MASK)) { - return 0; - } - if (len > (PAGE_SIZE * 3)) { - len = (2 * PAGE_SIZE) + (len & ~PAGE_MASK); - } - else { - len = (PAGE_SIZE - (PM_POS(pminf) & ~PAGE_MASK)); - } - } - pipemap_sync (area, area->vm_rstart, (size_t)len, 0); - return 0; - } - /* Kein Auto-commit notwendig ... */ - if ((bufpos - PM_POS(pminf)) <= (PM_AUTO(pminf) + AUTO_STEP)) - return 0; - - pipemap_sync (area, area->vm_rstart, - (size_t)((bufpos - PM_POS(pminf)) - PM_AUTO(pminf)), 0); - return 0; -} - - -/* Hinweise zu Pipe-Mapping: - * Swapin : Es ist eine vm-operation swapin zu definieren, die zuerst - * in der Pipe-PTE-Liste nachschaut, ob die Seite schon wieder zurueck- - * geladen wurde. wenn dies der Fall ist, braucht nur der PTE aus der - * Liste kopiert werden. Ist dies nicht der Fall so wird die in do_no_page() - * verwendete Funktion do_swap_page() aufgerufen und danach die Seite in die - * Pipe-PTE-Liste wieder eingetragen. - * Ein wie auch immer geartetes CoW darf hier nicht erfolgen ... - */ - -static pte_t pipemap_swapin (struct vm_area_struct *area, - unsigned long keine_Ahnung1, - unsigned long keine_Ahnung2) { - pte_t retval; - return retval; -} - -/* - * swapout : Hier ist die Situation etwas schwieriger; - * Die relevante Funktion ist swap_out(); alle in mm/vmscan.c; - * Diese Funktion versucht im Endeffekt durch try_to_swap_out() eine - * Seite auszulagern. Hier erfolgt dann auch der Aufruf der vm_op- - * Komponente swapout ..... - * Wird wohl notwendig sein das Auslagern der Seite in den VMAs aller - * Prozesse die diese Seite ebenfalls verwenden einzutragen. Damit kann dann - * davon ausgegangen werden, dass bei einem nachfolgenden Zugriff irgendeines - * Prozesses auf diese Seite der Umstand, dass sie ausgelagert ist richtig - * erkannt wird. - */ -static int pipemap_swapout (struct vm_area_struct *area, - unsigned long keine_Ahnung1, - pte_t * keine_Ahnung2) { - - - return 0; -} - -static void pipemap_close (struct vm_area_struct *area) { - - wake_up_interruptible(&PIPE_WAIT(*(area->vm_inode))); - return; -} - -/* - * unmap : Durch das unmap wird kein commit ausgeloest; weder bei einem - * partiellem, noch bei einem gesamten. Trotzdem muss aber im Falle - * eines unmaps der letzten read- oder write-Einblendung der - * entsprechende Grenzwert korrigiert werden, da ansonst der - * Zugriff ueber rerad()/write() gestoert wird. - * - * close : Wird nicht gebraucht, da immer wenn ein vm_op->close aufgerufen - * auch ein Aufruf von vm_ops->unmap erfolgt. - */ - -static void pipemap_unmap (struct vm_area_struct *vma, - unsigned long start, - size_t len, - struct task_struct *tsk) { - -#define MAX_VAL ((unsigned long) ~0) - - struct inode * inode; - struct pipe_mapper * pminf, * * pmlist, * pmprev; - unsigned long mval, pstart; - int umflag = 0; - - if (! (inode = vma->vm_inode)) { - printk("[%d] pipemap_unmap : VMA (0x%lx) with no inode ?!\n", - tsk->pid,vma->vm_start); - return; - } - - if (PIPE_MODE(*inode) == NORM_PIPE) { - printk("[%d] pipemap_unmap : pipe not in mmap-mode.\n", - tsk->pid); - return; - } - - if (! (pminf = VMA_PMAP(vma))) { - printk("[%d] pipemap_unmap : got VMA with no mapper-entry.\n", - tsk->pid); - send_sig(SIGKILL,tsk,1); - return; - } - - /* Beim Ausblenden muss u.U. auch ein msync/commit erfolgen. */ - - if (PM_MODE(pminf) == VM_RD_PIPE) { - pmlist = & MPIPE_READERS(*inode); - } - else { - pmlist = & MPIPE_WRITERS(*inode); - } - /* pminf muss aus der Liste ausgehaengt werden */ - - if (*pmlist == pminf) /* Erstes Element ? */ - *pmlist = pminf->next; - else { /* Irgendwo in der Liste */ - pmprev = *pmlist; - while (pmprev->next != pminf) - pmprev = pmprev->next; - pmprev->next = pminf->next; - } - - /* um den naechsten Minimalwert zu bestimmen. */ - - mval = minval(inode, MAX_VAL, PM_MODE(pminf)); - - /* Ausgegliedertes Listenelement wieder einhaengen. */ - - pminf->next = *pmlist; - *pmlist = pminf; - - if (mval == MAX_VAL) { /* Diese Mapperliste ist leer */ - if (PM_MODE(pminf) == VM_RD_PIPE) - mval = NPIPE_RSTART(*inode); - else - mval = NPIPE_WSTART(*inode); - } - - pstart = PM_ADDR(pminf, VMA_OFF(vma, start)); - - if ((vma->vm_start >= start) && (vma->vm_end <= start + len)) - umflag = 1; - - /* Wenn der gegebene Anfangswert start bestimmend fuer den Bereichs- - * grenzwert war, so muss wie bei einem normalen msync vorgegangen - * werden. Die Behandlung der beiden Faelle (ein/mehrere Mapper) - * sollte implizit vorhanden sein .... */ - - if (pstart < mval) { - unsigned long slen = mval - pstart; - /* Den bestimmenden Teil des unmap-Bereiches ermitteln : - * End unter oder ueber dem neuen Grenzwert ? bei unter ist - * dieser Wert der neue Grenzwert ! */ - if (pstart + len < mval) slen = len; - - psync(vma, start, slen, UNMAP_CALLS_PSYNC); - } - /* Die Folgenden Anweisungen werden in psync nur im msync-call Zweig - * aufgerufen (Problem wegen rm_pinf !!) */ - /* Wenn ein innerer Bereich eines VMAs betroffen ist, so wird - * das in der uebergeordneten Funktion durch open/unmap-Aufrufe - * beruecksichtigt. */ - - /* Ist der gesamte VMA betroffen, dann wird der zugehoerige - * Mapper-Entry entfernt und der Counter reduziert. */ - if (umflag) { - if (__HIGH(*inode)) - printk("punmap : rm whole entry\n"); - rm_pminf (inode, pminf); - } - else { /* Wird nur ein Teil am Anfang entfernt, dann wird der - * Startwert im Mapper-Entry nachgezogen. */ - PM_START(pminf) = start + len; - PM_POS(pminf) = pstart + len; - /* Eine Aenderung am Ende ist belanglos fuer den - * Mapper-Entry. */ - } - - /* Wenn es keine Einblendungen mehr gibt, wird die Pipe fuer den - * Normalbetrieb vorbereitet */ - if ( ! MPIPE_READERS(*inode) && ! MPIPE_WRITERS(*inode)) { - if (__HIGH(*inode)) - printk("[%d] unmap : cange mode to MTON_PIPE \n",tsk->pid); - /* pipemode_switch(inode) */ - PIPE_MODE(*inode) = MTON_PIPE; - } - wake_up_interruptible(&PIPE_WAIT(*inode)); - pipe_reset("PUNMAP", inode); - - return; -} - - - -/* - * open : Wird immer dann aufgerufen, wenn ein VMA der aus einem bestehenden - * entstanden ist, neu angelegt wird. Das ist bei allen VMA-Operationen - * unmap(), lock(), remap(), protect() und bei fork() der Fall. - * Fuer den neuen VMA muss ein neuer Mapper-Eintrag in entsprechenden - * (read/write) Mapper-Liste angelegt werden. - * Bei den besagten VMA-Operationen kann es zur Teilung eines VMAs - * kommen, wodurch ein neuer VMA-Eintrag entsteht. Inwieweit eine - * solche Teilung eines Pipe-Buffers sinnvoll ist soll hier einfach - * dem Anwender ueberlassen werden; es wird lediglich sichergestellt, - * dass es durch diese Operationen zu keinen Inkonsistenzen im VMM - * des Prozesses kommt. - * Anders ist die Situation im Falle eines Forks : Der entstehende Sohn- - * Prozess muss die eingeblendete Pipe korrekt uebernehmen. Dazu muss - * er ebenfalls in die Mapper-Listen eingetragen werden. - * Problem : Urspruenglich hat die open-Funktion lediglich einen Parameter nur - * ueber einen Parameter verfuegt. Damit ist aber die neu PID beim - * Fork nicht zugreifbar gewesen. Daher wurde die - * Funktionsdefinition abgeaendert. Sie erhaelt zwei neue Parameter. - * mode : um anzugeben von wo der Aufruf erfolgt - * addpara : Zusatzlicher Parameter zur freiene Verfuegung. Enthaelt - * beim Aufruf aus fork() die child-PID. - * Weiters waere es wuenschenswert, wenn die open()-Funktion einen Returnwert - * haette, der von den aufrufenden Funktionen entsprechend beruecksichtigt - * wird. - */ - -static void pipemap_open (struct vm_area_struct *vma, - int mode, - void * addpara){ - - struct task_struct *tsk = current; - struct inode * inode; - struct pipe_mapper *old_pminf, *new_pminf; - - - if (mode == VM_OC_NOOP) { - return; - } - if (mode == VM_OC_FORK) { - tsk = (struct task_struct *) addpara; - } - - if (! (inode = vma->vm_inode)) { - printk("[%d] pipemap_open : wrong VMA with no inode.\n", - tsk->pid); - send_sig(SIGKILL,tsk,1); - return; - } - - - if (PIPE_MODE(*inode) == NORM_PIPE) { - printk("[%d] pipemap_open : pipe not in mmap-mode.\n", - tsk->pid); - send_sig(SIGKILL,tsk,1); - return; - } - - /* Sollte die Pipe in Wartezustand zum Backswitch sein, so geht sie - * durch eine Neueinblendung in den MAP-Mode zurueck. */ - if (PIPE_MODE(*inode) == MTON_PIPE) PIPE_MODE(*inode) = MAP_PIPE; - - if (! (old_pminf = VMA_PMAP(vma))) { - printk("[%d] pipemap_open : got VMA with no mapper-entry.\n", - tsk->pid); - send_sig(SIGKILL,tsk,1); - return; - } - - VMA_PMAP(vma) = NULL; - - /* Eintrag fuer die Mapper-Liste erzeugen */ - if (!(new_pminf = (struct pipe_mapper *)kmalloc(\ - sizeof(struct pipe_mapper),GFP_KERNEL))) - { - oom(tsk); - return; - } - - PM_TASK(new_pminf) = tsk; - PM_FLAG(new_pminf) = PM_FLAG(old_pminf) & ~PM_SIG_MASK; - PM_AUTO(new_pminf) = PM_AUTO(old_pminf); /* Auto-Commit Indikator */ - PM_START(new_pminf) = vma->vm_start; - PM_POS(new_pminf) = vma->vm_offset; - - while (PIPE_LOCK(*inode)) { /* Pipe gelocked -> nochmals */ - printk("pipe-open : wait until pipe-unlock !\n"); - if (current->signal & ~current->blocked) { - printk("[%d] pipemap_open : signal force insert of entry\n", - CPID); - break; - } - interruptible_sleep_on(&PIPE_WAIT(*inode)); - } - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - - if (PM_MODE(new_pminf) == VM_RD_PIPE) { - new_pminf->next = MPIPE_READERS(*inode); - MPIPE_READERS(*inode) = new_pminf; - PIPE_READERS(*inode)++; - } - else { - new_pminf->next = MPIPE_WRITERS(*inode); - MPIPE_WRITERS(*inode) = new_pminf; - PIPE_WRITERS(*inode)++; - } - - VMA_PMAP(vma) = new_pminf; - - PIPE_LOCK(*inode)--; /* Pipe wird freigegeben .. */ - wake_up_interruptible(&PIPE_WAIT(*inode)); - - return; -} - - -/* sync : Diese Operation auf VMAs dient bei normalen Dateien dazu, eine - * Syncronisation zwischen RAM und Platte durchzufuhren. Bei der - * eingeblendeten Pipe ist soetwas nicht moeglich, daher kann diese - * Funktion die Aufgabe des commits erledigen. - * Bei einem commit erklaert ein Prozess einen Teil des Pipe-Buffers - * als abgeschlossen. Im Falle einer Write-Pipe steht dieser Bereich - * damit zum Lesen zur Verfuegung. Bei der Read-Pipe wird damit - * erklaert, das der angegebene Bereich ausgelesen wurde und nicht - * mehr weiter gebraucht wird (hier ergibt sich fuer msync und munmap - * die selbe Bedeutung). - * Interne Bedeutung : Write-msync : Der globale Write-Anfang muss - * erhoeht werden (MPIPE_WSTART, MPIPE_WOFF). Da dieser Wert jedesmal - * aus dem Read-Start und der Laenge errechnet wird, ist es der - * Laengenwert, der angepasst werden muss (PIPE_LEN). - * Schreib-sync => PIPE_LEN - * Read-msync : Es muss der Read-Anfang (MPIPE_RSTART, MPIPE_ROFF) und - * der Laengenwert (PIPE_LEN) angepasst werden. - * Lese-sync => MPIPE_RSTART, PIPE_LEN - * Der msync()-call ist in mm/filemap.c zu finden .... - */ -static int pipemap_sync (struct vm_area_struct *vma, /* der betroffenen VMA */ - unsigned long start, /* Anfangsadresse des Sync-Bereiches */ - size_t len, /* Laenge des Sync-Bereiches */ - unsigned int flags){ /* Sync-Flags (haben hier keine Bedeutung) */ - - return psync(vma, start, len, MSYNC_CALLS_PSYNC); -} - -static int psync (struct vm_area_struct *vma, /* der betroffenen VMA */ - unsigned long start, /* Anfangsadresse des Sync-Bereiches */ - size_t len, /* Laenge des Sync-Bereiches */ - char caller){ /* Sync-Flags (haben hier keine Bedeutung) */ - - struct vm_area_struct *v_vma; - struct inode * inode; - struct pipe_mapper * pminf; - unsigned long mval, - pstart, /* Die Pipe-Buffer Entsprechungen zu den */ - pend; /* Werten start und start + len. */ - - if (! (inode = vma->vm_inode)) { - printk("[%d] pmsync : wrong VMA (0x%lx) with no inode.\n",CPID,vma->vm_start); - return -EFAULT; - } - - /* mapper Eintrag ueber VMA-Verweis */ - - if (! (pminf = VMA_PMAP(vma))) { - printk("[%d] pipe-msync : got VMA with no mapper-entry.\n", - CPID); - return -EFAULT; - } - - pstart = PM_ADDR(pminf, VMA_OFF(vma, start)); - pend = pstart + len; - - /* Werte testen : Stimmt der Bereich ? - Wenn der angegebene Startwert ueber dem aktuellen - Anfangswert liegt, dann : - a: ignorieren und den Anfangswert als Start nehmen ... - (ist aber bestimmt nicht konservativ !) - b: Operation mit Fehler beenden ..... - darunter : Fehler - Obere Grenze : write : kann maximal vm_end sein; mehr geht - von msync her nicht. - read : was ist wenns ueber den write-Anfang geht ?? */ - - if (! len) return 0; - - - /* Untere Grenze muss genau am aktuellen Anfang liegen, ausser wenn - * sie im Bereich zwischen vm_start und vm_rstart liegt (wegen - * Aufruf ueber die unmap-Funktion) */ - if (pstart != PM_POS(pminf) && - ! (vma->vm_start <= start && start <= vma->vm_rstart)){ - if (caller == UNMAP_CALLS_PSYNC) { - return -EINVAL; - } - if (start > vma->vm_rstart) { - return -EINVAL; - } - } - - /* Eine Ueberschreitung der oberen Grenze braucht nicht abgefragt - * zu werden. Diese wird in allen darunterliegenden Aufrufen erkannt - * und beruecksichtigt. - */ - - /* Pipe sperren (warten) */ - - while (PIPE_LOCK(*inode)) { /* Pipe gelocked -> nochmals */ - printk("[%d] pipe-msync : wait until pipe-unlock !\n", - CPID); - interruptible_sleep_on(&PIPE_WAIT(*inode)); - /* Kommt ein offenes Signal dann nochmals aufrufen ... */ - if (current->signal & ~current->blocked) - return -ERESTARTSYS; - } - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - - /* Neuen globalen Anfangswert bestimmen : neuen Wert im mapper setzen und - dann mit diesem Wert durch die mapper-Liste gehen und auf < vergleichen; - ist er kleiner, dann mit diesem Wert weiter bis zum Listenende ... - Das ist dann der neue globale Wert. */ - - PM_POS(pminf) = pend; - - mval = minval(inode, PM_POS(pminf), PM_MODE(pminf)); - - if (PM_MODE(pminf) == VM_WR_PIPE){ - if (mval > MPIPE_BUF_END(*inode)) - mval = MPIPE_BUF_END(*inode); - if (caller == MSYNC_CALLS_PSYNC) - set_pflag(inode, pstart, len, PBF_SYNC); - if (MPIPE_WOFF(*inode) < mval) { - buf_shift(inode, mval, VM_WR_PIPE); - PIPE_LEN(*inode) += (mval - MPIPE_WOFF(*inode)); - /* MPIPE_WSTART wird aus MPIPE_START und PIPE_LEN berechnet, daher - * wird PIPE_LEN angepasst. NPIPE_START muss nur dann angepasst - * werden wenn der neue Schreibanfang darueber hinaus waechst. */ - if (NPIPE_WSTART(*inode) < mval) - NPIPE_WSTART(*inode) = mval; - } - } - else { - /* READ Pipe :: Jetzt muessen die freigewordenen Pages entfernt werden; - * Das PTE-Array muss geshiftet werden und alle Werte muessen angepasst - * werden. Wird durch buf_shift() erledigt. Die Anpassung des Laengenwertes - * wird nicht in buf_shift erledigt und muss explizit erfolgen. - * Beim sync der Lesepipe, darf natuerlich nicht in den Schreibbereich - * hineingesynct werden ! */ - if (MPIPE_WOFF(*inode) < mval) - mval = MPIPE_WOFF(*inode); - if (MPIPE_ROFF(*inode) < mval) { - if (NPIPE_RSTART(*inode) < mval) - NPIPE_RSTART(*inode) = mval; /* read()Anfang */ - PIPE_LEN(*inode) -= (mval - MPIPE_ROFF(*inode)); - buf_shift(inode, mval, VM_RD_PIPE); - } - } - - /* Beim Aufruf der munmap-Funktion muss im Falle des msyncs der - * Aufruf der mpipe-spezifischen unmap-Funktion verhindert werden, - * da es ansonst zu einer Endlos-Rekursion kommen wuerde. - * Daher muss auch hier im else-Zweig bei Teil-Sync der Mapper-VMA- - * Startwert korrigiert werden. */ - - if (caller == MSYNC_CALLS_PSYNC) { - int opflag = 1; - - /* Letzte Manipulationen am Mapper-Entry und am VMA */ - - if ((start <= vma->vm_rstart) && (vma->vm_rend <= start + len)) - { - if (__HIGH(*inode)) - printk("punmap : rm whole entry\n"); - PIPE_LOCK(*inode)--; - rm_pminf (inode, pminf); - PIPE_LOCK(*inode)++; - opflag = 0; - } - else { /* Wird nur ein Teil am Anfang entfernt, dann wird der - * Startwert im Mapper-Entry nachgezogen. (start ist - * ein r-Wert !) */ - PM_START(pminf) = (start + len) & PAGE_MASK; - - /* Eine Aenderung am Ende ist belanglos fuer den - * Mapper-Entry. */ - } - vma->vm_ops->unmap = NULL; - do_munmap(start, len); - - if (opflag) { /* ansonst gibts den vma ja nicht mehr .. */ - v_vma = find_vma(current->mm, start+len); - if ((v_vma != vma) || - (v_vma->vm_start != vma->vm_start)) - vma = v_vma; - vma->vm_ops->unmap = pipemap_unmap; - } - } - /* Sicher ist sicher .... */ - if ( ! MPIPE_READERS(*inode) && ! MPIPE_WRITERS(*inode)) { - printk("[%d] psync : cange mode to MTON_PIPE\n",current->pid); - /* pipemode_switch(inode) */ - PIPE_MODE(*inode) = MTON_PIPE; - } - - - /* Pipe freigeben und wartende Prozesse wecken. */ - - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - - return 0; -} - -/* - * Ein vma_op-vektor fuer Private-Read-Pipe der nur die nopage und unmap - * Funktion braucht. Ansonst reicht das Defaultverhalten. - * Das stimmt so nicht : Wegen der Notwendigkeit, jede Seite bis zum ersten - * Schreibzugriff zu Synchronisieren, ist auch im PRIVATE-Fall der selbe - * Operationsvektor noetig. Das Erkennen eines PRIVATE-Mappings muss in - * den Funktionen selbst erfolgen. - * Fuer alle anderen Faelle ein zweiter Vektor mit : nopage, swapin, swapout - * unmap und sync (das macht das commit !!!!). - - * Wenn eine Lese-Pipe PRIVATE gemapped wird : - * In diesem Fall muss beim ersten schreibenden Zugriff auf eine Seite - * diese a) kopiert werden - * und b) die Kopplung zur Pipe-PTE-Liste aufgehoben werden. - * Fuer die anderen Seiten, die nur lesend zugegriffen wurden bleibt die - * Synchronisation mit der Pipe-PTE-Liste aufrecht. - * Erkennung : bei swapin bzw nopage kann man bezueglich der Seite das - * Schreibbit pruefen (pte_write()); wenn im vma_flag MAP_PRIVATE - * ist und die Seite nicht mehr schreibgeschuetzt ist, dann wurde - * sie bereits kopiert und ist eigenstaendig; es ist auch durch - * einen Vergleich der page-Adressen lokal und PTE-Liste - * feststellbar - aber nur wenn die Seite in der Liste nicht als - * ausgelagert gefuehrt wird. - * - */ - -/* pipemap_nopage() : Diese Funktion wird in den VMA-Operationsvektor - * als nopage-Komponente eingetragen. - * Sie soll die Adresse der gewuenschten Page liefern; alle - * notwendigen Eintragungen in der Prozess-Page-Table werden - * von der aufrufenden Funktion durchgefuehrt. - * Wird Aufgerufen wenn : - * - Die Seite noch nicht eingeblendet wurde ... - * wobei es aber sein kann, dass die gewuenschte Seite aber - * gerade Ausgelagert ist. - * - * * Die passende Seite zum Einblenden ist in der PTE-Liste der Pipe - * zu finden. Es muss der richtige PTE in der Liste ermittelt werden. - * Es wird die Adresse der Page gebraucht. - * * Wenn die Seite in der PTE-Liste als Ausgelagert angegeben ist, muss - * die Einlagerung angestossen werden. Dabei muss aber darauf geachtet - * werden, nur die Adresse der Page zu erhalten, und moeglichst noch - * keine Eintragungen in der Page-Table vorzunehmen, da diese ja in - * der aufrufenden Funktion do_no_page() erfolgen. - * - * no_share : Dieser Parameter wurde uebergeordnet schon durch Auswertung - * der Page-Protection, der Area-Protection und der Zugriffsart ermittelt. - * FALSE (0) : MAP_SHARED oder MAP_PRIVATE mit Lesezugriff. - * TRUE (1) : Area ist MAP_PRIVATE und Schreibzugriff. Das Kopieren - * muss hier erfolgen. Die Adresse der neuen Kopie wird - * zurueckgegeben. In der Folge muss bei swapin/swapout - * die Unabhaengigkeit der Seite beruecksichtigt werden. - * address : Problem, da das nicht die tatsaechliche Zugriffsadresse ist, - * sondern in do_no_page() durch & PAGE_MASK auf den Seitenanfang - * gezogen wurde. Damit kann man nicht feststellen, ob innerhalb der - * Grenz-Seite zu tief oder zu hoch adressiert wurde ! Korrektur in - * do_no_page() geht soweit ok. - * Achtung : bei Fehler brauchts ev noch ein oom(current) !!! - */ - -static unsigned long pipemap_nopage(struct vm_area_struct *area, \ - unsigned long address, int no_share){ - - struct inode * inode; - char *page = NULL; - struct pipe_mapper * pminf; - int pte_idx=0, wait=0; /* wait ist FALSE */ - struct vm_area_struct *v_vma; - - inode = area->vm_inode; - - - if (!(inode->i_pipe)) { - printk("Access to PIPE-VMA with non-pipe inode !!\n"); - return 0; /* Falscher VMA !!! ist keine Pipe !!! */ - } - - /* Diese Pruefung muss wegen der Erweiterung des VMM erfolgen (Offsets) - * Vorerst wird festgelegt, dass ein Zugriff ausserhalb des - * eigentlichen VMA-Bereiches sofern er erkannt wird, als Fehler - * gewertet wird (Er kann nicht immer erkannt werden, nur wenn - * dadurch ein Seitenfehler ausgeloest wurde). Der address-Wert gibt - * aber erst durch die &PAGE_MASK-Korrektur in do_no_page() den - * tatsaechlichen Wert wieder. */ - if ((address < VMA_RSTART(area)) || address > VMA_REND(area)) { - printk("[%d] Access outside the VMA detected !!\n", CPID); - return 0; - } - - - /* Mapper-Eintrag ueber VMA-Verweis zugreifen */ - - if (! (pminf = VMA_PMAP(area))) { - printk("[%d] no Mapper-entry in VMA ... \n", CPID); - return 0; - } - /* SIGPIPE-Flag loeschen .... */ - PM_FLAG(pminf) &= ~PM_SIG_PIPE; - - /* Ermitteln des Index in der PTE-Liste und Test ob er ueber dem - * derzeitigen Maximalwert liegt. Ist das der Fall, so muss entweder - * der Buffer (die PTE-Liste) erweitert, oder auf das Fortschreiten - * des Buffers gewartet werden (im RD- und WR-Fall gleich) . - * Weiters muss bei einem Zugriff auf die Lesepipe darauf geprueft - * werden ob an der Adresse schon freigegebene Daten stehen. Wenn - * nicht muss gewartet werden. Ein Zugriff auf eine Schreib-pipe - * kann nicht zu tief (unter den Anfang des Schreibbereiches) gehen, - * weil das schon ausserhalb des VMAs liegen wuerde ! */ - - -/* PROBLEM : bei return 0 bekommt der Prozess ein SIGBUS von do_no_page(); - * Wie soll man in der Applikation darauf reagieren ? - * Wenn man SIGBUS abfaengt und weitermacht, hat man die BAD_PAGE - * an die betreffende Stelle bekommen !!?? - * Soll man noch ein SIGPIPE dazugeben ?? (bei read() kommt man in - * diesen Faellen einfach mit einer read-Size 0 zurueck ...) */ - do { - wait = 0; /* wait ist FALSE */ - - auto_sync(area, inode, address); - /* VMA koennte veraendert worden sein ! */ - v_vma = find_vma(current->mm, address); - if ((v_vma != area) || - (v_vma->vm_start != area->vm_start)) - area = v_vma; - - pte_idx = PM_PTEIDX(PM_BOFF(inode, pminf, \ - VMA_OFF(area, address))); - - if (pte_idx >= PIPE_BUF_PAGES(*inode)) { - wait = 1; - } - - /* Lesen macht nur Sinn, wenn es jemand gibt, der schreibt */ - if (MPIPE_EMPTY(*inode)) { /* Wenn sie leer ist und niemand */ - if (!PIPE_WRITERS(*inode)){ /* etwas schreiben wird */ - pm_sigpipe(pminf); - return 0; /* dann gibts nichts zu lesen. */ - } - } - - /* Wenns eine Lesepipe ist, dann kann ein Zugriff nur im page - * alligned Lesebereich erfolgen; darueberhinaus muss auf - * neue Daten gewartet werden. (NOTE: Anzahl Schreiber ??) - * Reihenfolge ist Wichtig : read_last_page muss in Falle - * eines Zugriffs auf die Seite nach der letzten Seite bei - * einem Pipe-Ende ein Signal senden und es wird eine leere - * Seite geliefert um ein SIGBUS zu verhindern => Page-Trick */ - if ((PM_MODE(pminf) == VM_RD_PIPE) && - ((! (page = (char *) read_last_page (inode, pte_idx, pminf))) && - (PM_ADDR(pminf, VMA_OFF(area, address)) >= \ - (MPIPE_WOFF(*inode) & PAGE_MASK)))){ - wait = 1; - } - - /* Pipe muss spaeter selbst gelocked werden ... */ - if (PIPE_LOCK(*inode)) wait = 1; - if ((PM_MODE(pminf) == VM_WR_PIPE) && - ((!PIPE_READERS(*inode) || PIPE_WAIT(*inode) == NULL))) { - wait = 1; - } -/* do_no_page liefert am Pipe-Ende auf jeden Fall zumindest ein leere Seite - * retour. Um dem Prozess etwas mitzuteilen, wird hier auf alle Faelle ein - * PIPE-Signal an ihn gesendet. Damit hat er die Moeglichkeit, mittels - * ioctl()-Calls in einem Signalhaendler darauf zu reagieren. Fuer die - * betroffene Einblendung wird auch das SIGPIPE-Flag gesetzt. */ - if (wait) { - if (pipe_end(inode,PM_MODE(pminf))){ - printk("[%d] pipemap_nopage : pipe end\n", - CPID); - pm_sigpipe(pminf); - return 0; - } - if ((PM_MODE(pminf) == VM_RD_PIPE) && - PIPE_WRITERS(*inode) && MPIPE_EMPTY(*inode)) - wake_up_interruptible(&PIPE_WAIT(*inode)); - - interruptible_sleep_on(&PIPE_WAIT(*inode)); - - if (current->signal & ~current->blocked) { - printk("[%d] mpipe-nopage : Signal received !\n", - CPID); - return 0; - } - } - } while (wait); - - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - - /* Wenn unter diesem Index noch keine Seite zu finden ist : - - * Das kann nur mehr bei einer Schreibpipe der Fall sein, da wir - * bei der Lesepipe schon auf die Seite gewartet haben ... */ - - if (page > (char *) 1) { -/* Signal wird schon in read_last_page gesendet .... - send_sig(SIGPIPE,current,0); */ - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return (unsigned long) page; - } - - if (pte_none(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx]))) { - if (PM_MODE(pminf) == VM_RD_PIPE) { - printk("[%d] pipe-nopage : page_non in read-pipe !\n", - CPID); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - /* Schreibzugriff : ganz neue Seite; muss erst angelegt - * und in die PTE-Liste eingetragen werden. */ - page = (char *) get_free_page(GFP_USER); - if (page == NULL) { - printk("[%d] pipe-nopage : can't get free page !\n", - CPID); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx]) = - mk_pte((unsigned long) page, PAGE_SHARED); - pb_init(MPIPE_PLIST(*inode)[pte_idx]); - pb_use(MPIPE_PLIST(*inode)[pte_idx]); - } - - /* An dieser Stelle ist sichergestellt, dass an der Stelle pte_idx - * der PTE_Liste ein Page-Table Entry zu finden ist. */ - - if (! pte_present(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx]))){ - - /* Die Seite existiert bereits, ist aber ausgelagert. - * Die Seite ist in der PTE-Liste als Ausgelagert markiert. - * Kann nur sein, wenn diese Adresse noch nie von diesem Prozess - * zugegriffen wurde. */ - /* PTE kopieren und normales swapin() aufrufen; - * dabei sollte dann ueber die pipemap_swapin() Funktion - * die Eintragung in die PTE-Liste erfolgen. Ausser wenn - * der VMA MAP_PRIVATE ist und der Zugriff schreibend war - * no_share = TRUE - dann muss kopiert werden. - * Die korrekte Eintragung in die Prozess Page-Tabelle erfolgt - * in der swapin()-Funktion. */ - - /* Jetzt wird der Page-Tabellen-Eintrag gebraucht ! */ - - pgd_t * pgd; - pmd_t * pmd; - pte_t * page_table, entry; - - - printk("[%d] mpipe-nopage : SWAP-IN ....\n",CPID); - printk("[%d] sorry - not implemented yet -- kill !!\n",CPID); - send_sig(SIGTERM,current,0); - - - pgd = pgd_offset(current->mm, address); - pmd = pmd_alloc(pgd, address); - if (!pmd){ - printk("pipe-nopage : pmd_alloc-errror !\n"); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - page_table = pte_alloc(pmd, address); - if (!page_table){ - printk("pipe-nopage : pte_alloc-error !\n"); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - /* Sichern des Original-PTEs */ - pte_val(entry) = pte_val(*page_table); - /* Kopieren des PTE-List Entrys .. */ - set_pte(&pte_val(*page_table), - pte_val(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx]))); - - /* der pipemap_swapin() Aufruf ... */ - /* Dieser Aufruf liefert die Page des betreffenden PTE-List - * Entrys wenn sie gerade ausgelagert ist. Ein eventuell - * notwendiges CoW muss hier ausserhalb der Funktion erfolgen, - * da diese Funktion ansonst nur fuer Seiten die schon in der - * Prozess-Page-Table stehen, aufgerufen wird. - * ACHTUNG :: die unlock -lock Sache muss noch ueberdacht - * werden ! */ - - PIPE_LOCK(*inode)--; /* kein wakeup, da nur fuer die swapin- - * Funktion freigegeben */ - page = (char *) pte_page(pipemap_swapin(area, - address - area->vm_rstart + area->vm_offset, - (unsigned long) pte_val(entry))); - - PIPE_LOCK(*inode)++; - - /* mpipe_swapin() hat die Seite bereits in den Entry der - * PTE-Liste eingetragen; darum muss man sich hier nicht - * mehr kuemmern. */ - - /* Wiederherstellen des Original-Page-Table Entrys */ - *page_table = entry; - - if (! page) { - printk("mpipe_nopage : can't get page from swapin !\n"); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - - pb_use(MPIPE_PLIST(*inode)[pte_idx]); - /* Jetzt steht die Seite in der PTE-Liste zur Verfuegung; - * daher braucht hier nichts mehr weiter gemacht werden. */ - } - - /* Da die Seite jetzt in der PTE_Liste vorhanden ist, kann sie als - * gewuenschter Wert zurueckgeliefert werden. Nur im Falle eines - * Schreibzugriffs auf eine MAP_PRIVATE Seite einer Read-Pipe muss - * ein CoW erfolgen. Die Auswertung wurde aber schon durchgefuehrt - * und es braucht nur mehr der Parameter no_share abgefragt zu - * werden. - * Wenn eine nicht-zugegriffene Seite von einem write-commit betroffen - * war, dann wurde der PTE mit der ZERO_PAGE initialisiert. Diese Seite - * muss jetzt durch eine leere Seite ersetzt werden. */ - - page = (char *) pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx])); - - if ((unsigned long) page == ZERO_PAGE) { - page = (char *) get_free_page(GFP_USER); - if (page == NULL) { - printk("pipe-nopage : can't get free page !\n"); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx]) = - mk_pte((unsigned long) page, PAGE_SHARED); - - } - - /* Wenn eine Seite nur durch unmap freigegeben wurde fehlt das SYNC- - * Flag. In diesem Fall ist der Inhalt ungueltig und muss geloescht - * werden. */ - - if (PM_MODE(pminf) == VM_RD_PIPE && - ! (MPIPE_PFLAGS(MPIPE_PLIST(*inode)[pte_idx]) & PBF_SYNC)) { - memset((void *) pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx])), - 0,PAGE_SIZE); - pb_sync(MPIPE_PLIST(*inode)[pte_idx]); - } - - if (no_share) { - page = (char *) get_free_page(GFP_USER); - if (page == NULL) { - printk("pipe-nopage : can't get free page !\n"); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return 0; - } - memcpy((void *) page, \ - (void *) pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx])), - PAGE_SIZE); - } - else { - /* Es muss der Use-count der Page erhoeht werden. - * Damit wird auch sichergestellt, dass bei einem - * MAP_PRIVATE Lesezugriff die WriteProdect-Bedingung - * erfuellt ist (count > 1) und die Seite schreibge- - * schuetzt wird. */ - mem_map[MAP_NR(page)].count++; - } - /* Das scheint fuer die Faelle wo eine neue Seite im Spiel ist, noetig - * zu sein .... */ - flush_tlb_mm(current->mm); - flush_page_to_ram((unsigned long) page); - flush_page_to_ram(pte_page(MPIPE_PTE(MPIPE_PLIST(*inode)[pte_idx]))); - /* Wird halt bei RD-Pipe nochmals gemacht - ist aber egal .. */ - pb_use(MPIPE_PLIST(*inode)[pte_idx]); - - /* Zugriffszeiten entsprechend der Operation RD/WR aktualisieren */ - if (PM_MODE(pminf) == VM_WR_PIPE) - inode->i_atime = inode->i_mtime = CURRENT_TIME; - else - UPDATE_ATIME(inode); - - - PIPE_LOCK(*inode)--; - /* Wartende Prozesse aufwecken .... */ - wake_up_interruptible(&PIPE_WAIT(*inode)); - /* Jetzt kann man davon ausgehen, dass : - * 1: die page in die pte-Liste eingetragen ist, - * 2: Wenn noetig die Seite kopiert wurde .... - * In allen Faellen wurde jetzt die Adresse der benoetigten Seite - * ermittelt. Diese kann jetzt zurueckgegeben werden. */ - - return (unsigned long) page; -} - -static struct vm_operations_struct pipe_mmap_ops = { - pipemap_open, /* open */ - pipemap_close, /* close */ - /* NULL, */ /* close */ - pipemap_unmap, /* unmap - Pipe-Struktur Update. */ - NULL, /* no special protect */ - pipemap_sync, /* sync */ - /* NULL, */ /* sync */ - NULL, /* advise */ - pipemap_nopage, /* nopage */ - NULL, /* wppage */ - pipemap_swapout, /* swapout */ - pipemap_swapin, /* swapin */ -}; - - - - -/* pipe_mmap() : Einblenden einer Pipe in den virtuellen Adressraum - * eines Prozesses. Wird im Operationsvektor der - * File-Operationen angegeben. Diese Funktion wird als Objekt- - * spezifischer Mapper in do_mmap() aufgerufen. - */ - - -#define RD_FIFO (pmode) -#define WR_FIFO (! pmode) - - -static int pipe_mmap (struct inode * inode, struct file * filp, \ - struct vm_area_struct * vma) -{ - struct pipe_mapper * mapper; - unsigned long offset = vma->vm_offset + (vma->vm_rstart & ~PAGE_MASK); - int pmode, stream_flag = (int) vma->vm_pte; - - /* Der angegeben Offset darf nicht hinter dem zur Zeit - * gueltigen Anfang der Pipe liegen (irgendwann werden Seiten - * verworfen) und je nach Zugriffsart muss darf er nicht hinter - * dem entsprechenden Offset liegen. ( man kann sehr wohl die Pipe - * zum Lesen mit einem Offset der z.Z. noch in den Schreibbereich - * verweist einblenden; nur der Zugriff ist noch nicht moeglich - * Die aktuelle Schreib/Lese-OffsetWerte koennen mit ioctl() - * ausgelesen werden. - * Wobei die Werte bei einer Pipe im Normalmodus adaptiert werden. - * Solange die Pipe im Normalmodus ist, ist der map-Offset 0, - * der Schreib-Offset ist immer Page-Alligend und der Lese-Offset - * wird aus Buffergroesse weniger Inhaltslaenge errechnet. - * (Vergleich mit PIPE_xOFF-Makros). */ - - - vma->vm_pte = 0; - - if (((filp->f_mode == FMODE_WRITE) && (stream_flag == MAP_RDSTREAM))|| - ((filp->f_mode == FMODE_READ) && (stream_flag == MAP_WRSTREAM))) - return -EACCES; - - if ((filp->f_mode == FMODE_WRITE) || (stream_flag == MAP_WRSTREAM)) { - pmode = 0; - } - else - if ((filp->f_mode == FMODE_READ) || - (stream_flag == MAP_RDSTREAM)) { - pmode = 1; - } - else { - return -EACCES; - } - - - if (PIPE_MODE(*inode) == NORM_PIPE) - { - if ((WR_FIFO && (offset < PIPE_WOFF(*inode))) || - (RD_FIFO && (offset < PIPE_ROFF(*inode)))) - return -EINVAL; - } - else - { - if ((WR_FIFO && (offset < MPIPE_WOFF(*inode))) || - (RD_FIFO && (offset < MPIPE_ROFF(*inode)))) - return -EINVAL; - } - - /* Die Schreib-Pipe darf nur SHARE eingeblendet werden. */ - /* Muss schon auf do_mmap()-Ebene geprueft werden, da in den vm_flags - * keine Info ueber die MAP-Art enthalten ist !! */ - - if (WR_FIFO && ! (vma->vm_flags & VM_SHARED)) - { - return -EINVAL; - } - /* Unabhaengig vom File-Mode sollen die Bereiche alle moeglichen - * Flags (read/write/exec) haben. Die Bereiche sollen den Prozessen - * ja zum Arbeiten zur Verfuegung stehen. Daher werden die MY-Flags - * einfach ergaenzt. */ - vma->vm_flags |= VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC; - - /* Eintrag fuer die Mapper-Liste erzeugen */ - if (!(mapper = (struct pipe_mapper *)kmalloc(\ - sizeof(struct pipe_mapper),GFP_KERNEL))) - return -ENOMEM; - - /* Erste Initialisierungen des Mapper-Eintrages */ - PM_TASK(mapper) = current; /* Kein Auto-Commit ... */ - - /* Da der Pipe-Record veraendert werden soll, - * muss er gesperrt werden. */ - if (PIPE_LOCK(*inode)) { /* Pipe gelocked -> nochmals */ - kfree(mapper); - printk("Can't mmap Pipe - locked !\n"); - return -EAGAIN; - } - PIPE_LOCK(*inode)++; /* Pipe wird gelocked .. */ - /* Die Umstellung der Pipe erfolgt unabhaengig davon, ob der aktuelle - * Aufruf die Lese- oder Schreib-Pipe betrifft. */ - if (PIPE_MODE(*inode) == NORM_PIPE) { - /* Speicher fuer die PTE-Liste reservieren .. */ - if (!(MPIPE_PLIST(*inode) = - (struct pbpage *) kmalloc(sizeof(struct pbpage)* - (DEFAULT_BUF_PAGES), - GFP_KERNEL))) { - kfree(mapper); - printk("Can't mmap Pipe - no mem !\n"); - PIPE_LOCK(*inode)--; - wake_up_interruptible(&PIPE_WAIT(*inode)); - return -ENOMEM; - } - - memset(MPIPE_PLIST(*inode), 0, - sizeof(struct pbpage)*(DEFAULT_BUF_PAGES)); - /* In Abhaengigkeit des aktuellen Bufferinhaltes ist - * unterschiedlich vorzugehen : - * - Buffer ist Leer : keine besondere Aktion ... - * - Buffer ist Voll : Die Seite wird als erste in die - * PTE-Liste eingetragen. - * - Buffer hat Inhalt : Der Inhalt muss linearisiert und - * End-Buendig in die erste(n) Seite(n) - * der PTE-Liste eingetragen werden. - * Die Eintragung der Seiten ins Page-Dir des Prozesses erfolgt - * erst durch die Ausloesung einer Page-Excetpion beim ersten - * Zugriff auf die Seite. - */ - - /* Beim Kopieren des Bufferinhaltes wird davon ausgegangen, - * dass der Buffer einen geschlossenen Adressbereich einnimmt. - * Entweder weil er nur eine Speicherseite gross ist (also - * mit get_free_page()), oder durch kmalloc() als zusamen- - * haengender Bereich angelegt oder mit vmalloc() in den - * Kernel-Adressraum eingeblendet wurde. */ - if (!MPIPE_EMPTY(*inode)) { - int newpages, i; - unsigned long s_len, d_len, s_start, s_end; - char *page, *d_start=NULL; - newpages = FULL_PAGES(PIPE_LEN(*inode)); - s_start = PIPE_START(*inode); /* Offset !! */ - s_end = PIPE_END(*inode); /* Offset !! */ - /* Das Wertepaar (0,0) geht nicht !! */ - if (! s_start && \ - (PIPE_LEN(*inode) == PIPE_BUF_SIZE(*inode))) - s_end = s_start + PIPE_LEN(*inode); - for (i=newpages-1; i>=0; i--) { /* zwengan index .. */ - if (! (page=(char *)get_free_page(GFP_USER))) { - kfree(mapper); - /* Freigabe der gerade geholten pages */ - for (i++; i s_start) ? (s_end - s_start):\ - (PIPE_BUF_SIZE(*inode) - (s_start - s_end)); - d_len = (unsigned long) (d_start - page); - if (d_len > s_len) { - /* Bufferinhalt(rest) passt in die Seite */ - memcpy(d_start - s_len,\ - s_start + PIPE_BASE(*inode),\ - s_len); - d_start -= s_len; - s_end -= s_len; - } - else { - /* Diese Seite ist voll; neue Seite ... */ - memcpy(page, \ - PIPE_BASE(*inode)+(s_end-d_len),\ - d_len); - d_start -= d_len; - s_end -= d_len; - } - /* Page-Table-Entry erzeugen ... */ - - set_pte(&pte_val((MPIPE_PTE(MPIPE_PLIST(*inode)[i]))), - pte_val(mk_pte((unsigned long) page, - (pgprot_t) PAGE_SHARED))); - pb_sync(MPIPE_PLIST(*inode)[i]); - d_start -= (unsigned long) page; - } /* for ... */ - MPIPE_START(*inode) = (unsigned long) d_start; - /* Position fuer normalen Zugriff ... */ - NPIPE_START(*inode) = MPIPE_START(*inode); - NPIPE_WSTART(*inode) = MPIPE_WOFF(*inode); - } /* if nicht Leer ... */ - MPIPE_BASE(*inode) = 0; - PIPE_BUF_SIZE(*inode) = DEFAULT_BUF_SIZE; - /* Loeschen der Normal-Pipe Werte */ - vfree(PIPE_BASE(*inode)); - PIPE_BASE(*inode) = NULL; - PIPE_DLEV(*inode) = INIT_PD; - /* Das Setzen des Modus erst zuletzt, da einige Makros davon - * abhaengen. */ - PIPE_MODE(*inode) = MAP_PIPE; /* Modus setzen. */ - } - - /* Sollte die Pipe in Wartezustand zum Backswitch sein, so geht sie - * durch eine Neueinblendung in den MAP-Mode zurueck. */ - if (PIPE_MODE(*inode) == MTON_PIPE) PIPE_MODE(*inode) = MAP_PIPE; - - /* Letzte Initialisierungen des Mapper-Eintrages und der Inode. */ - PM_AUTO(mapper) = AUTO_SIZE(*inode); - PM_START(mapper) = vma->vm_start; /* Zum Wiederfinden .. */ - PM_POS(mapper) = offset; - - if (WR_FIFO) { - mapper->next = MPIPE_WRITERS(*inode); - MPIPE_WRITERS(*inode) = mapper; - PIPE_WRITERS(*inode)++; - PM_FLAG(mapper) = VM_WR_PIPE; - } - else { - mapper->next = MPIPE_READERS(*inode); - MPIPE_READERS(*inode) = mapper; - PIPE_READERS(*inode)++; - PM_FLAG(mapper) = VM_RD_PIPE; - } - - /* Was noch fehlt : Zuweisung eines VMA-Op-Vektors ... */ - /* Initialisierung einiger Inode-Komponenten : - * i_count, i_dirt, i_atime ... */ - UPDATE_ATIME(inode); /* Hier kein '*' !!!! */ - vma->vm_inode = inode; - inode->i_count++; /* muss beim unmap -- gemacht werden */ - vma->vm_ops = &pipe_mmap_ops; - VMA_PMAP(vma) = mapper; - - PIPE_LOCK(*inode)--; /* Sperre aufheben ... */ - wake_up_interruptible(&PIPE_WAIT(*inode)); - - return 0; /* Alles OK .... */ -} - - - -/* Initialisierung der File- und Inode-Operationsvektoren. - * Die Freigabe des Speichers fuer diverse Datenstrukturen erfolgt - * nicht in einer close() Funktion, da es eine solche nicht gibt. - * Es gibt lediglich eine release()-Komponente im File-Op-Vektor. - * Im Inode-Vektor gibt es keine close()-Komponente. Im Verlauf eines - * close()-System-Calls wird die Funktion iput() (fs/inode.c) aufgerufen, - * um die Inode wieder freizugeben. In dieser Funktion wird explizit auf - * die Art der Inode abgefragt. Im Falle der Pipe muss dann der Speicher - * fuer die PTE-Liste wieder Freigegeben werden. */ - -/* - * The file_operations structs are not static because they - * are also used in linux/fs/fifo.c to do operations on fifo's. - */ - -struct file_operations connecting_fifo_fops = { - pipe_lseek, - connect_read, - bad_pipe_w, - NULL, /* no readdir */ - connect_select, - pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* no mmap on pipes.. surprise */ - pipe_read_open, - pipe_read_release, - NULL -}; - -/* Die fifo-Operationsvektoren read_fifo_fops, write_fifo_fops und - * rewr_fifo_fops werden im wesentlichen nur wegen dem unterschiedlichen - * select()-Verhalten von SunOS gebraucht. Sie unterscheiden sich von - * den Pipe-Varianten nur durch den Wert fuer die Select-Komponente. - * Der Grund dafuer ist das unterschiedliche Verhalten des select() - * Aufrufs fuer FIFOs (siehe oben). - * Im Fall dass normales Verhalten erwuenscht ist, wird fifo_select() - * pipe_select definiert. - */ - -struct file_operations read_fifo_fops = { - pipe_lseek, - pipe_read, - bad_pipe_w, - NULL, /* no readdir */ - fifo_select, - pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* no mmap on pipes.. surprise */ - pipe_read_open, - pipe_read_release, - NULL -}; - -struct file_operations write_fifo_fops = { - pipe_lseek, - bad_pipe_r, - pipe_write, - NULL, /* no readdir */ - fifo_select, - pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* mmap */ - pipe_write_open, - pipe_write_release, - NULL -}; - -struct file_operations rdwr_fifo_fops = { - pipe_lseek, - pipe_read, - pipe_write, - NULL, /* no readdir */ - fifo_select, - pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* mmap */ - pipe_rdwr_open, - pipe_rdwr_release, - NULL -}; - -/* - * Die beiden Operationsvektoren read_pipe_fops und write_pipe_fops - * werden in do_pipe() bei der Initialisierung der Komponente - * f_op der file-Datenstrukturen fuer die read- und write-Pipe verwendet. - */ +struct file_operations rdwr_fifo_fops = { + pipe_lseek, + pipe_read, + pipe_write, + NULL, /* no readdir */ + fifo_select, + pipe_ioctl, + NULL, /* mmap */ + pipe_rdwr_open, + pipe_rdwr_release, + NULL +}; struct file_operations read_pipe_fops = { pipe_lseek, @@ -3230,8 +354,7 @@ NULL, /* no readdir */ pipe_select, pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* no mmap on pipes.. surprise */ + NULL, /* no mmap on pipes.. surprise */ pipe_read_open, pipe_read_release, NULL @@ -3244,24 +367,12 @@ NULL, /* no readdir */ pipe_select, pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* mmap */ + NULL, /* mmap */ pipe_write_open, pipe_write_release, NULL }; -/* Initialisierung der File-Operations-Structure fuer Pipes. - * Genauer : fuer lese/schreib Pipes ... - * Die Definition der Structur ist in include/linux/fs.h zu finden. - * Diese Variable ist eine Teilkomponente der Inode-Operations (siehe - * unten ....) und gibt an welche Funktionen fuer die diversen - * File-Operationen auf Pipes verwendet werden. - * Hier befindet sich auch der Einstiegspunkt fuer die Realisierung - * des Pipe-Mappings !! Jetzt wird fuer die zu verwendende Mapping- - * Funktion NULL angegeben ... - */ - struct file_operations rdwr_pipe_fops = { pipe_lseek, pipe_read, @@ -3269,24 +380,12 @@ NULL, /* no readdir */ pipe_select, pipe_ioctl, - pipe_mmap, /* surprise : new mmap on pipes ... */ - /* NULL, */ /* mmap */ + NULL, /* mmap */ pipe_rdwr_open, pipe_rdwr_release, NULL }; -/* Initialisierung der operations-structure. Hier wird festgelegt, - * welche Funktionen fuer die diversen Inode-Operationen auf Pipes - * angewendet werden. Der struct inode_operation-Type wird in - * include/linux/fs.h definiert. Nachdem die Pipe ja kein wirkliches - * Objekt eines Filesystems repraesentiert, werden keine Funktionen - * fuer diese Inode-Operationen gebraucht und NULL zugewiesen. - * Einzig fuer die Komponente default_file_ops (struct file_operations *) - * erfolgt eine Wertzuweisung. Die Initalisierung von rdwr_pipe_fops - * ist in dieser Datei (pipe.c) zu finden. - */ - struct inode_operations pipe_inode_operations = { &rdwr_pipe_fops, NULL, /* create */ @@ -3307,112 +406,61 @@ NULL /* permission */ }; -/* - * do_pipe() ist der eigentliche pipe()-Systemaufruf. - * Verhalten der Pipe : immer blockierend (siehe f_flag) - */ - int do_pipe(int *fd) { - struct inode * inode; /* Def in Include/linux/fs.h */ - struct file *f1, *f2; /* Def in Include/linux/fs.h */ - + struct inode * inode; + struct file *f1, *f2; int error; int i,j; error = -ENFILE; - /* get_empty_filp (in linux/fs/file_table.c) liefert uns eine - * leere File-Structur. Fuer die Pipe werden aber zwei davon - * gebraucht; eine fuer den Schreib-Zugang und eine fuer den - * Lese-Zugang. - */ f1 = get_empty_filp(); if (!f1) goto no_files; f2 = get_empty_filp(); if (!f2) - goto close_f1; /* Erste File-Struct wieder freigeben .. */ + goto close_f1; - /* Die Pipe wird wie jedes andere File behandelt. Daher wird - * fuer die Darstellung und Verwaltung eine neue Inode ereugt. - * Diese Funktion ist in linux/fs/inode.c zu finden. - */ inode = get_pipe_inode(); if (!inode) goto close_f12; - /* Es werden 2 freie Filedeskriptoren gebraucht (siehe fs/open.c) - * Filedeskriptoren sind Integers -- Index in einem Array, das zu - * jedem Prozess existiert und die Filepointer - Pointer auf - * eine Element der globalen File-Structure Liste -- dieses - * Prozesses enthaelt. - */ error = get_unused_fd(); if (error < 0) goto close_f12_inode; - i = error; + i = error; error = get_unused_fd(); if (error < 0) goto close_f12_inode_i; j = error; - /* Beide Filepointer zeigen auf die selbe Inode. Die Pipe wird durch - * diese Inode repraesentiert. Die Pipe ist ein File auf das getrennt - * mit einem Lese- und einem Schreib-Pointer zugegriffen wird. - */ f1->f_inode = f2->f_inode = inode; - f1->f_pos = f2->f_pos = 0; /* Startposition fuers Lesen u Schreiben */ - /* Initialisierung des Lese-Files .... */ /* read file */ - f1->f_flags = O_RDONLY; /* Nur-Lese-Flag setzen .... */ - f1->f_op = &read_pipe_fops; /* Fileoperationen fuer die Lese-Pipe. */ - /* f1->f_mode = 1; Original */ /* File-Mode Lesen ... */ - /* new : Syro ist nur Kosmetik */ - f1->f_mode = FMODE_READ; /* File-Mode Lesen ... */ - /* new end */ - /* Initialisierung des Schreib-Files .... */ + f1->f_pos = f2->f_pos = 0; + f1->f_flags = O_RDONLY; + f1->f_op = &read_pipe_fops; + f1->f_mode = 1; /* write file */ - f2->f_flags = O_WRONLY; /* Nur-Schreiben-Flag setzen .... */ - f2->f_op = &write_pipe_fops; /* Fileoperationen f. d. Schreib-Pipe. */ - /* f2->f_mode = 2; Original */ /* File-Mode Schreiben ... */ - /* new : Syro ist nur Kosmetik */ - f2->f_mode = FMODE_WRITE; /* File-Mode Schreiben ... */ - /* new end */ - - /* Eintrag der Filepointer der Pipe ins Filepointer-Array der - * Prozess-Struktur unter den Filedeskriptoren als Index. - */ + f2->f_flags = O_WRONLY; + f2->f_op = &write_pipe_fops; + f2->f_mode = 2; current->files->fd[i] = f1; current->files->fd[j] = f2; - /* Die beiden ermittelten Delkriptoren werden als Pipe in einem - * zwei-elementigem Deskriptor-Array als Ergebnis geliefert. - */ fd[0] = i; fd[1] = j; - return 0; /* Erfolgreiches Ende des Pipe-Calls */ - - /* In den unterschiedlichen Fehlerfaellen muessen die zuvor erfolgten - * Operation rueckgaengig gemacht werden. - */ + return 0; close_f12_inode_i: - put_unused_fd(i); /* Filedeskriptor freigeben .. */ + put_unused_fd(i); close_f12_inode: - inode->i_count--; /* Inode freigeben .. */ + inode->i_count--; iput(inode); close_f12: - f2->f_count--; /* Schreib-Filepointer freigeben .. */ + f2->f_count--; close_f1: - f1->f_count--; /* Lese-Filepointer freigeben .. */ + f1->f_count--; no_files: return error; } - - - - - - - --- /usr/src/linux-work/fs/fifo.c Sun Oct 10 11:48:41 1999 +++ /usr/src/linux/fs/fifo.c Mon Mar 11 10:23:22 1996 @@ -10,21 +10,6 @@ #include #include - -/* Syro : new : - * Hinweise zum Einblenden von FIFOs : - * Die Angabe von O_NOBLOCK bei open() der named pipe hat keinen Einfluss - * auf das Verhalten der eingeblendeten FIFO. Diese zeigt immer ein - * blockierendes Verhalten. - * FIFO-open nach POSIX : (kein Prozess hat die FIFO offen) - * im BLOCK-mode : RDONLY und WRONLY warten bis die FIFO zur gegenteiligen - * Operation geoeffnet wird. RDWR blockiert nie. - * bei NONBLOCK : RDONLY liefert sofort die geoeffnete FIFO; - * WRONLY liefert sofort einen Fehler (ENXIO); RDWR ist nicht definiert - - * wird hier wie RDONLY behandelt. - * PROBLEM : Wie soll RDWR aufgefasst werden ?? - */ - static int fifo_open(struct inode * inode,struct file * filp) { int retval = 0; @@ -95,7 +80,7 @@ case 3: /* * O_RDWR - * POSIX.1 leaves this case 'undefined' when O_NONBLOCK is set. + * POSIX.1 leaves this case "undefined" when O_NONBLOCK is set. * This implementation will NEVER block on a O_RDWR open, since * the process can at least talk to itself. */ @@ -115,50 +100,16 @@ } if (retval || PIPE_BASE(*inode)) return retval; - /* Syro : new : Da bei der eingeblendeten Pipe PIPE_BASE = NULL ist, - * muss dieser Fall gesondert erkannt werden. */ - - if (PIPE_MODE(*inode)) { -printk("[%d] fifo-open : return with mmaped pipe .. \n",current->pid); - return 0; - } - /* Fortsetzung nur dann, wenn die Inode neu ist und daher noch kein - * Buffer vorhanden ist. Es muessen alle Werte der Inode initialisiert - * werden; wie in get_pipe_inode() (fs/inode.c) */ - /* SYRO : Hier sollte eigentlich auf die selben Werte wie beim - * Erzeugen des PIPE-Buffers zur"uckgegriffen werden, da alle - * weiteren Operationen die selben wie bei der Pipe sind .... */ - /* page = __get_free_page(GFP_KERNEL); Original */ - /* page = __get_free_pages(GFP_KERNEL, (unsigned long) PIPE_ORD, 0); */ - /* Test ... page = vmalloc((unsigned long) PIPE_BUF); */ - /* new : FIFO ist eine traditionelle Pipe */ - PIPE_BUF_SIZE(*inode) = PIPE_BUF; - PIPE_MODE(*inode) = NORM_PIPE; - /* new: end */ - page = (unsigned long) vmalloc((unsigned long) PIPE_BUF_SIZE(*inode)); - printk("FIFO: Alocate mem (inode-Nr %lu)\n", inode->i_ino); - /* Dieses IF scheint toter Code zu sein ! Aber wenn man bedenkt, dass - * der __get_free_page-Aufruf wegen GFP_KERNEL == GFP_USER unter- - * brechbar ist, koennte in der Zwischenzeit jemand anderer einen - * Buffer angelegt haben ... */ + page = __get_free_page(GFP_KERNEL); if (PIPE_BASE(*inode)) { - printk("FIFO: Free mem - Interrupted (inode-Nr %lu)\n", inode->i_ino); - vfree((void*)page); - /* free_pages(page, PIPE_ORD); */ - /* free_page(page); Original */ + free_page(page); return 0; } - if (!page) { - printk("FIFO: Can't alocate mem (inode-Nr %lu)\n", inode->i_ino); + if (!page) return -ENOMEM; - } PIPE_LOCK(*inode) = 0; - PIPE_START(*inode) = PIPE_LEN(*inode) = NPIPE_WSTART(*inode)= 0; + PIPE_START(*inode) = PIPE_LEN(*inode) = 0; PIPE_BASE(*inode) = (char *) page; - /* new : MPIPE_xxxx Initalisierungen */ - MPIPE_PLIST(*inode) = NULL; - MPIPE_READERS(*inode) = MPIPE_WRITERS(*inode) = NULL; - /* new: end */ return 0; } @@ -210,24 +161,4 @@ PIPE_RD_OPENERS(*inode) = PIPE_WR_OPENERS(*inode) = 0; PIPE_WAIT(*inode) = NULL; PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 0; - /* Syro : new : */ - PIPE_BUF_SIZE(*inode) = PIPE_BUF; - PIPE_MODE(*inode) = NORM_PIPE; - MPIPE_START(*inode) = 0; - MPIPE_PLIST(*inode) = NULL; - MPIPE_READERS(*inode) = MPIPE_WRITERS(*inode) = NULL; - MPIPE_BASE(*inode) = 0; } - - - - - - - - - - - - - --- /usr/src/linux-work/fs/inode.c Mon Feb 21 23:33:01 2000 +++ /usr/src/linux/fs/inode.c Thu Nov 13 05:36:41 1997 @@ -8,12 +8,9 @@ #include #include #include -#include /* Syro : new - wegen der PIPE-Makros */ #include -#include /* Syro : new - wegen kfree() */ #include -#include /* Syro : new - wegen pte_page() */ #define NR_IHASH 512 @@ -441,16 +438,8 @@ } } -/** - ** iput gibt eine Inode-Structur wieder frei. Dabei muessen je nach - ** Typ der Inode objektspezifische Operationen ausgefuehrt werden. - ** (warum es dafuer kein Element im inode_operations Vektor gibt ??) - **/ - void iput(struct inode * inode) { - int i; - if (!inode) return; wait_on_inode(inode); @@ -471,51 +460,10 @@ wake_up(&inode_wait); if (inode->i_pipe) { - /** hier wird die fuer Pipe verwendete Speicherseite - ** wieder freigegeben **/ - /* new : natuerlich muessen hier alle Speicherbereiche die fuer das - * Einblenden der Pipe benoetigt wurden auch wieder explizit frei- - * gegeben werden. */ - struct pipe_mapper * mapp = NULL; unsigned long page = (unsigned long) PIPE_BASE(*inode); - if (inode->i_mmap != NULL) - printk("[%d] iput i_mmap != NULL .....\n",current->pid); PIPE_BASE(*inode) = NULL; - /* SYRO fuer mehrere Seiten ... */ - /* free_page(page); original */ - vfree((void*)page); /* new : vmalloc-Buffer .. */ - /* new : Freigabe der Buffer-Pages ... - * Achtung : Die Seiten sollten nicht vorher schon - * freigegeben werden; Folgen unbekannt !! */ - if (MPIPE_PLIST(*inode) != NULL){ - for (i = 0; i < PIPE_BUF_PAGES(*inode); i++) - if (! pte_none(MPIPE_PTE(MPIPE_PLIST(*inode)[i]))){ - free_pte(MPIPE_PTE(MPIPE_PLIST(*inode)[i])); - pte_clear(&(MPIPE_PTE(MPIPE_PLIST(*inode)[i]))); - } - /* new : Freigabe des Speichers der Page-Liste. */ - kfree((void *) MPIPE_PLIST(*inode)); -printk("[%d] free inode (iput) done ...\n",current->pid); - } - MPIPE_PLIST(*inode) = NULL; - if (MPIPE_READERS(*inode) || MPIPE_WRITERS(*inode)) - printk("[%d] iput : existing Mapper-Entrys !!!!\n", - current->pid); - - while (MPIPE_READERS(*inode)) { - mapp = MPIPE_READERS(*inode); -printk("[%d] iput : del mapper-entry : %lu\n", current->pid, (unsigned long )mapp); - MPIPE_READERS(*inode) = mapp->next; - kfree((void *) mapp); - } - while (MPIPE_WRITERS(*inode)) { - mapp = MPIPE_WRITERS(*inode); -printk("[%d] iput : del mapper-entry : %lu\n", current->pid, (unsigned long) mapp); - MPIPE_WRITERS(*inode) = mapp->next; - kfree((void *) mapp); - } - - } + free_page(page); + } if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) { inode->i_sb->s_op->put_inode(inode); @@ -623,83 +571,30 @@ return best; } - -/** Liefert eine neue Inode fuer eine Pipe. Die Inode wird mit allen - ** erforderlichen Werten initialisiert. Die externe Variable - ** pipe_inode_operations wird in fs/pipe.c initialisiert. Sie - ** definiert die Inode-Operationen fuer Pipes. - ** Die Typ-Definitionen sind in include/linux/fs.h zu finden. - ** Die PIPE_... Macros werden in include/linux/pipe_fs_i.h definiert. - ** Sie dienen dazu den filesystem-spezifischen Teil u der inode- - ** structure zu initialisieren. Diese Komponente ist als union definiert - ** und nimmt im Falle der Pipes einen Wert des Typs struct pipe_inode_info - ** an (siehe include/linux/pipe_fs_i.h). - ** PIPE_BUF ist in include/linux/limits.h zu finden. - **/ struct inode * get_pipe_inode(void) { struct inode * inode; extern struct inode_operations pipe_inode_operations; - /** Freie Inode wird angefordert ... **/ if (!(inode = get_empty_inode())) return NULL; - /** Initialisieren des FIFO-Puffers. Es wird vorerst eine Speicher- - ** Seite reserviert. - **/ -/* ori if (!(PIPE_BASE(*inode) = (char*) __get_free_page(GFP_USER))) { */ - - /** Zuordnen des pipe-spezifischen Inode-Operationsvektors **/ - inode->i_op = &pipe_inode_operations; - /* new : Vorerst traditionelle Pipe ... */ - PIPE_BUF_SIZE(*inode) = PIPE_BUF; - PIPE_MODE(*inode) = NORM_PIPE; - /* new: end */ - /* new : vmalloc() um groessere Buffer zu ermoeglichen */ - if (!(PIPE_BASE(*inode) = (char*) vmalloc((unsigned long) PIPE_BUF_SIZE(*inode)))) { - printk("Pipe: can't alloc mem ...\n"); - iput(inode); /* Freigabe der Inode im Fehlerfall !! */ + if (!(PIPE_BASE(*inode) = (char*) __get_free_page(GFP_USER))) { + iput(inode); return NULL; } - - /** old : Zuordnen des pipe-spezifischen Inode-Operationsvektors **/ - /* old : Verlegt ... inode->i_op = &pipe_inode_operations; */ - /** Referenzzaehler - Summe der Leser und Schreiber; muss bei der - ** Pipe immer in Zweierspruengen steigen. - **/ - inode->i_count = 2; /* sum of readers/writers */ - PIPE_WAIT(*inode) = NULL; /* Warteschlange ... */ - PIPE_START(*inode) = PIPE_LEN(*inode) = NPIPE_WSTART(*inode) = 0; - /** pipe_.._openers ist nur bei einer FIFO von bedeutung; Auf - ** Pipes kann ja kein open() mit irgendwelchen Modis angewendet - ** werden. Diese Werte werden auch nur in fs/fifo.c manipuliert. - **/ + inode->i_op = &pipe_inode_operations; + inode->i_count = 2; /* sum of readers/writers */ + PIPE_WAIT(*inode) = NULL; + PIPE_START(*inode) = PIPE_LEN(*inode) = 0; PIPE_RD_OPENERS(*inode) = PIPE_WR_OPENERS(*inode) = 0; - /** Die Pipe wird ja von niemanden geoeffnet. Sobald sie erzeugt - ** wird, ist auch ein Prozess lesend/schreibend dran; daher - ** werden hier die entsprechenden Zaehler erhoeht. - **/ PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1; - PIPE_LOCK(*inode) = 0; /* Lock */ - /* new : MPIPE_xxxx Initalisierungen */ - MPIPE_START(*inode) = 0; - MPIPE_PLIST(*inode) = NULL; - MPIPE_READERS(*inode) = MPIPE_WRITERS(*inode) = NULL; - MPIPE_BASE(*inode) = 0; - /* new: end */ - inode->i_pipe = 1; /* Flag : Inode ist eine Pipe !! */ - inode->i_mode |= S_IFIFO | S_IRUSR | S_IWUSR; /* Modus und Rechte */ - inode->i_uid = current->fsuid; /* Eigentuemer UID */ - inode->i_gid = current->fsgid; /* Eigentuemer GID */ - /** Zeit der letzten Aenderung (mtime), des letzten Zugriffs (atime) - ** und der Erzeugung (ctime) ist aktuelle Zeit.... - **/ + PIPE_LOCK(*inode) = 0; + inode->i_pipe = 1; + inode->i_mode |= S_IFIFO | S_IRUSR | S_IWUSR; + inode->i_uid = current->fsuid; + inode->i_gid = current->fsgid; inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; - inode->i_blksize = PAGE_SIZE; /* Block-Groesse */ - /* new : Andere Darstellung der Buffer-Groesse - * ev fsck-Fehlerursache ?? -- nein ... trotzdem scheint - * PAGE_SIZE vernuenftiger zu sein. */ - /* inode->i_blksize = PIPE_BUF_SIZE(*inode); */ /* Block-Groesse */ + inode->i_blksize = PAGE_SIZE; return inode; } @@ -798,15 +693,3 @@ remove_wait_queue(&inode->i_wait, &wait); current->state = TASK_RUNNING; } - - - - - - - - - - - - --- /usr/src/linux-work/fs/exec.c Tue Jun 8 17:45:25 1999 +++ /usr/src/linux/fs/exec.c Mon Jul 13 22:47:34 1998 @@ -292,11 +292,7 @@ if (mpnt) { mpnt->vm_mm = current->mm; mpnt->vm_start = PAGE_MASK & (unsigned long) p; - /* Syro : new : offset ist 0 !! */ - mpnt->vm_rstart = mpnt->vm_start; mpnt->vm_end = STACK_TOP; - /* Syro : new : */ - mpnt->vm_rend = mpnt->vm_end; mpnt->vm_page_prot = PAGE_COPY; mpnt->vm_flags = VM_STACK_FLAGS; mpnt->vm_ops = NULL; @@ -380,10 +376,6 @@ return result; } -/* Syro : new : exit_mmap() braucht auch die Task-Stuctur als Parameter. - * (siehe mm/mmap.c) - */ - static int exec_mmap(void) { /* @@ -391,9 +383,7 @@ * to the page directory when shared, except for graceful abort */ if (current->mm->count > 1) { - struct mm_struct *old_mm, - *mm = kmalloc(sizeof(*mm), GFP_KERNEL); - + struct mm_struct *old_mm, *mm = kmalloc(sizeof(*mm), GFP_KERNEL); if (!mm) return -ENOMEM; @@ -405,13 +395,13 @@ mm->total_vm = 0; mm->rss = 0; - old_mm = current->mm; + old_mm = current->mm; current->mm = mm; if (new_page_tables(current)) { /* The pgd belongs to the parent ... don't free it! */ mm->pgd = NULL; current->mm = old_mm; - exit_mmap(current->mm, current); /* Syro : new : */ + exit_mmap(mm); kfree(mm); return -ENOMEM; } @@ -421,7 +411,7 @@ * all threads exited while we were sleeping, 'old_mm' is held * by us exclusively, lets get rid of it: */ - exit_mmap(old_mm, current); /* Syro : new : */ + exit_mmap(old_mm); free_page_tables(old_mm); kfree(old_mm); } @@ -429,7 +419,7 @@ return 0; } flush_cache_mm(current->mm); - exit_mmap(current->mm, current); /* Syro : new : */ + exit_mmap(current->mm); clear_page_tables(current); flush_tlb_mm(current->mm); @@ -712,15 +702,3 @@ free_page(bprm.page[i]); return(retval); } - - - - - - - - - - - - --- /usr/src/linux-work/fs/buffer.c Thu May 27 13:33:27 1999 +++ /usr/src/linux/fs/buffer.c Sun Nov 15 19:33:11 1998 @@ -254,12 +254,6 @@ int file_fsync (struct inode *inode, struct file *filp) { - /* Syro : new : Da diese Funktion auch mit der Inode einer Pipe - * aufgrufen werden koennte, wird jetzt auf das Vorhandensein eines - * Devices getestet. Ist der Inode keines zugeordnet, so wird der - * Aufruf normal beendet. */ - - if (! inode->i_dev) return 0; return fsync_dev(inode->i_dev); } --- /usr/src/linux-work/fs/proc/array.c Tue Mar 23 22:36:24 1999 +++ /usr/src/linux/fs/proc/array.c Mon May 15 14:16:18 2000 @@ -863,16 +863,12 @@ * + (index into the line) */ /* for systems with sizeof(void*) == 4: */ -/* #define MAPS_LINE_FORMAT4 "%08lx-%08lx %s %08lx %s %lu\n" - Syro : new : */ -#define MAPS_LINE_FORMAT4 "%08lx %08lx - %08lx %08lx %s %08lx %s %lu\n" -#define MAPS_LINE_MAX4 69 /* 49 sum of 8 1 8 1 4 1 8 1 5 1 10 1 */ +#define MAPS_LINE_FORMAT4 "%08lx-%08lx %s %08lx %s %lu\n" +#define MAPS_LINE_MAX4 49 /* sum of 8 1 8 1 4 1 8 1 5 1 10 1 */ /* for systems with sizeof(void*) == 8: */ -/*#define MAPS_LINE_FORMAT8 "%016lx-%016lx %s %016lx %s %lu\n" - Syro : new : */ -#define MAPS_LINE_FORMAT8 "%016lx %016lx - %016lx %016lx %s %016lx %s %lu\n" -#define MAPS_LINE_MAX8 109 /* 73 sum of 16 1 16 1 4 1 16 1 5 1 10 1 */ +#define MAPS_LINE_FORMAT8 "%016lx-%016lx %s %016lx %s %lu\n" +#define MAPS_LINE_MAX8 73 /* sum of 16 1 16 1 4 1 16 1 5 1 10 1 */ #define MAPS_LINE_MAX MAPS_LINE_MAX8 @@ -929,8 +925,7 @@ len = sprintf(line, sizeof(void*) == 4 ? MAPS_LINE_FORMAT4 : MAPS_LINE_FORMAT8, - map->vm_start, map->vm_rstart, map->vm_rend, - map->vm_end, str, map->vm_offset, + map->vm_start, map->vm_end, str, map->vm_offset, kdevname(dev), ino); if (column >= len) { --- /usr/src/linux-work/ipc/shm.c Sun Jun 13 20:24:44 1999 +++ /usr/src/linux/ipc/shm.c Sun Nov 15 19:33:19 1998 @@ -25,8 +25,7 @@ static int newseg (key_t key, int shmflg, int size); static int shm_map (struct vm_area_struct *shmd); static void killseg (int id); -/* Syro : new : open hat neue Parameter */ -static void shm_open (struct vm_area_struct *shmd, int mode, void * par); +static void shm_open (struct vm_area_struct *shmd); static void shm_close (struct vm_area_struct *shmd); static pte_t shm_swap_in(struct vm_area_struct *, unsigned long, unsigned long); @@ -534,9 +533,6 @@ shmd->vm_pte = SWP_ENTRY(SHM_SWP_TYPE, id); shmd->vm_start = addr; shmd->vm_end = addr + shp->shm_npages * PAGE_SIZE; - /* Syro : new : da offset = 0 rstart = start; rend sowieso = end */ - shmd->vm_rstart = shmd->vm_start; - shmd->vm_rend = shmd->vm_end; shmd->vm_mm = current->mm; shmd->vm_page_prot = (shmflg & SHM_RDONLY) ? PAGE_READONLY : PAGE_SHARED; shmd->vm_flags = VM_SHM | VM_MAYSHARE | VM_SHARED @@ -565,8 +561,7 @@ } /* This is called by fork, once for every shm attach. */ -/* Syro : new : 2. + 3. open-Parameter */ -static void shm_open (struct vm_area_struct *shmd, int mode, void *nouse) +static void shm_open (struct vm_area_struct *shmd) { unsigned int id; struct shmid_ds *shp; @@ -589,7 +584,6 @@ * The descriptor has already been removed from the current->mm->mmap list * and will later be kfree()d. */ - static void shm_close (struct vm_area_struct *shmd) { struct shmid_ds *shp; --- /usr/src/linux-work/kernel/fork.c Sun Jun 13 21:59:44 1999 +++ /usr/src/linux/kernel/fork.c Thu Jun 4 00:17:50 1998 @@ -77,10 +77,7 @@ return last_pid; } -/* Syro : new : struct task_struct *tsk. Siehe dazu naechsten Kommentar. */ - -static inline int dup_mmap(struct mm_struct * mm, - struct task_struct * tsk) +static inline int dup_mmap(struct mm_struct * mm) { struct vm_area_struct * mpnt, **p, *tmp; @@ -111,8 +108,7 @@ return -ENOMEM; } if (tmp->vm_ops && tmp->vm_ops->open) - /* Syro : new : */ - tmp->vm_ops->open(tmp, VM_OC_FORK, (void *) tsk); + tmp->vm_ops->open(tmp); *p = tmp; p = &tmp->vm_next; } @@ -121,13 +117,6 @@ return 0; } -/* Syro : new : Die Funktion exit_mmap() braucht auch den betreffenden Task - * da dieser im Fork-Fall ja ein anderer als current sein kann. - * Diese Information wird von der Funktion vm_ops->unmap() gebraucht. - * Um diesen Wert auch an die in dup_mmap() aufgerufenen vm_ops->open() - * Funktion weitergeben zu koennen, wird die Parameterliste von dup_mmap() - * ebenfalls um einen Task-Pointer erweitert. - */ static inline int copy_mm(unsigned long clone_flags, struct task_struct * tsk) { if (!(clone_flags & CLONE_VM)) { @@ -143,15 +132,15 @@ tsk->cmin_flt = tsk->cmaj_flt = 0; tsk->nswap = tsk->cnswap = 0; if (new_page_tables(tsk)) { - exit_mmap(mm, tsk); /* Syro : new : */ tsk->mm = NULL; + exit_mmap(mm); goto free_mm; } down(&mm->mmap_sem); - if (dup_mmap(mm, tsk)) { + if (dup_mmap(mm)) { up(&mm->mmap_sem); - exit_mmap(mm, tsk); /* Syro : new : */ tsk->mm = NULL; + exit_mmap(mm); free_page_tables(mm); free_mm: kfree(mm); @@ -334,18 +323,3 @@ bad_fork: return error; } - - - - - - - - - - - - - - - --- /usr/src/linux-work/kernel/exit.c Tue Jun 8 17:35:01 1999 +++ /usr/src/linux/kernel/exit.c Thu Jun 4 00:17:50 1998 @@ -499,7 +499,7 @@ /* free the old state - not used any more */ if (!--mm->count) { - exit_mmap(mm, tsk); /* Syro : new : */ + exit_mmap(mm); free_page_tables(mm); kfree(mm); } --- /usr/src/linux-work/arch/i386/kernel/ptrace.c Sun May 9 21:41:18 1999 +++ /usr/src/linux/arch/i386/kernel/ptrace.c Mon Jul 13 22:47:27 1998 @@ -197,17 +197,8 @@ return NULL; if (vma->vm_end - addr > tsk->rlim[RLIMIT_STACK].rlim_cur) return NULL; - /* Syro : new : Hier kommt es sehr oft zu einem Offset-Underflow. - * offset ist ein unsigned long, daher wird kein negativer offset - * erzeugt, sondern ein sehr grosser ??!!. - * Der Wert wird jetzt minimal 0 .... */ - /* vma->vm_offset -= vma->vm_start - addr; Syro : old .. */ - vma->vm_offset = \ - vma->vm_offset < vma->vm_offset - (vma->vm_start - addr)?0:\ - vma->vm_offset - (vma->vm_start - addr); - + vma->vm_offset -= vma->vm_start - addr; vma->vm_start = addr; - vma->vm_rstart = vma->vm_start; /* Syro : new : */ return vma; } --- /usr/src/linux-work/include/linux/mman.h Thu Mar 9 14:37:44 2000 +++ /usr/src/linux/include/linux/mman.h Wed May 29 13:50:50 1996 @@ -3,14 +3,6 @@ #include -/* Syro : new : Pip-mmap-Defines fuer den User */ - -#ifndef __KERNEL__ - -#include - -#endif - #define MREMAP_MAYMOVE 1 #endif /* _LINUX_MMAN_H */ --- /usr/src/linux-work/include/linux/mm.h Thu Mar 9 14:37:29 2000 +++ /usr/src/linux/include/linux/mm.h Tue Apr 4 17:24:42 2000 @@ -26,101 +26,40 @@ * mm details, and allowing different kinds of memory mappings * (from shared memory to executable loading to arbitrary * mmap() functions). - ** Virtual mm wird genauso wie das virtuelle Filesystem verwendet - ** um eine saubere Schnittstelle fuer die Speicherverwaltung zu - ** realisieren. Es erlaubt verschiedene Arten des memory mappings - ** (von shared mem ueber das Laden von Programmen hin zu beliebigen - ** mmap() Funktionen */ /* * This struct defines a memory VMM memory area. There is one of these * per VM-area/task. A VM area is any part of the process virtual memory - * space that has a special rule for the page-fault handlers ([id est] ie - * a shared library, the executable area etc). - ** Diese Datenstruktur definiert einen Virtuellen Speicherbereich. - ** (Virtual Memory - VM) Das Datensegment im Nutzersegment wird in - ** dieser Form logisch unterteilt. Es gibt genau - ** eine solche Struktur fuer jeden VM-Bereich/Task. Jeder Abschnitt des - ** virtuellen Speichers eines Prozesses, der eine eigene Regel fuer den - ** page fault handler hat, stellt einen VM-Bereich dar (z.B. shared - ** libs, der Bereich in dem der ausfuehrbare Code liegt). + * space that has a special rule for the page-fault handlers (ie a shared + * library, the executable area etc). */ struct vm_area_struct { struct mm_struct * vm_mm; /* VM area parameters */ - /* vm_mm : Zeiger auf einen Teil eines Prozesstabelleneintrages */ - unsigned long vm_start; /* Anfang des Areas */ - /* Syro : new vm_rstart */ - unsigned long vm_rstart; /* Tatsaechlicher Anfang des Areas */ - unsigned long vm_end; /* Ende */ - /* Syro : new vm_rend */ - unsigned long vm_rend; /* Tatsaechliches Ende */ - pgprot_t vm_page_prot; /* Protection */ - unsigned short vm_flags; /* Flags */ -/* Drei Arten der Verknuepfung der einzelnen Virt. Speicherbereiche : */ -/* AVL tree of VM areas per task, sorted by address -** AVL - Baum der VM-Bereiche pro task, nach Adressen sortiert .. */ + unsigned long vm_start; + unsigned long vm_end; + pgprot_t vm_page_prot; + unsigned short vm_flags; +/* AVL tree of VM areas per task, sorted by address */ short vm_avl_height; struct vm_area_struct * vm_avl_left; struct vm_area_struct * vm_avl_right; /* linked list of VM areas per task, sorted by address */ -/* Einfach verkettete Liste nach Adressen sortiert .. */ struct vm_area_struct * vm_next; /* for areas with inode, the circular list inode->i_mmap */ /* for shm areas, the circular list of attaches */ /* otherwise unused */ -/* Doppelt verkettete Liste (Ringliste) fuer spezielle Faelle; - * Bei Mappings mit inodes wird die Liste inode->i_mmap und bei - * ShareMemorys die Liste der attaches damit gebildet. - */ struct vm_area_struct * vm_next_share; struct vm_area_struct * vm_prev_share; /* more */ - struct vm_operations_struct * vm_ops; /* Zusaetzliche Operationen */ -/* wird mit diversen Mapping-Funktionen initialisiert; mm/filemap.c */ -/* vm_offset : Offset an dem das/die Geraet/Inode (vm_inode) in den virt. - * Speicherbereich eingeblendet ist. -*/ + struct vm_operations_struct * vm_ops; unsigned long vm_offset; - struct inode * vm_inode; /* wenn == NULL : anonymes Mapping ! */ -/* Syro : new : Fuer das Einblenden von Pipes werden einige zusaetzliche - * Informationen benoetigt. Diese werden einer, der Pipe-Beschreibung - * zugeordneten Liste abgelegt. Es besteht ein eindeutiger Zusammenhang - * zwischen einem VMA und einer solchen Beschreibung. Um diesen auch - * zu ermoeglichen, wird in vm_pte ein Zeiger auf sie abgelegt. Diese - * Komponente wird nur im Falle von Shared Memorys verwendet und ist - * ansonsten Bedeutungslos. - */ + struct inode * vm_inode; unsigned long vm_pte; /* shared mem */ }; -/* Syro : new : - * Macros fuer den Zugriff auf Komponenten des VMAs ... - */ - -/* Macros fuer absolute und relative Anfangs- und Endwerte im VMA. - * Wobei diese Macros ev. nach mm.h verschoben werden sollten. - * Es ist erst die Erweiterung der VMA-struct und des ganzen VMM um die - * effektiven (nicht-page-alligned) Werte zu implementieren. */ - -#define VMA_START(vma) ((vma)->vm_start) -#define VMA_RSTART(vma) ((vma)->vm_rstart) -/* #define VMA_RSTART(vma) ((vma)->vm_start) */ -#define VMA_SOFF(vma) (VMA_RSTART(vma) - VMA_START(vma)) - -#define VMA_END(vma) ((vma)->vm_end) -#define VMA_REND(vma) ((vma)->vm_rend) -/* #define VMA_REND(vma) ((vma)->vm_end) */ -#define VMA_EOFF(vma) (VMA_REND(vma) - VMA_START(vma)) - -/* Der Offset Wert in Bezug auf den tatsaechlichen Anfang des VMAs */ -#define VMA_OFF(vma, addr) (addr - VMA_RSTART(vma)) - -/* new end */ - /* * vm_flags.. - * Die VM_xxx Flags bedeuten, dass der entsprechende Zugriff erlaubt ist. */ #define VM_READ 0x0001 /* currently active flags */ #define VM_WRITE 0x0002 @@ -153,56 +92,21 @@ * These are the virtual MM functions - opening of an area, closing and * unmapping it (needed to keep files on disk up-to-date etc), pointer * to the functions called when a no-page or a wp-page exception occurs. - ** Funktionen zur Verwaltung der Virtuellen Speicherbereiche. Die - ** werden im Falle eines Ausnahmefehlers bei Zugriff auf eine Speicher- - ** seite im entsprechenden virtuellen Speicherbereich von der Ausnahme- - ** fehlerbehandlungroutiene aufgerufen. - */ -/* Syro : new - Kosmetik; Variablen-Namen entfern .... - * Die Bedeutung der Parameter ist noch unklar !! - * unmap : vm_area, .... - * prodect, advise und wppage in Version 2.0.xx nicht verwendet; mit - * Suche nach ->.... in den Sourcen ueberprueft => scheint zu stimmen ... - * Initialisierungen : mm/filemap.c no open,close - * fs/pipe.c - * fs/fat/mmap.c no open,close,unmap - * fs/ncpfs/mmap.c no open,close,unmap - * fs/smbfs/mmap.c no open,close,unmap - * ipc/shm.c no unmap - * - * Syro : new : 2 neue Parameter bei open. - * int mode : um festzustellen von wo aufgerufen wurde; - * void * : fuer allfaellige weitere Parameter (zb. PID bei fork) - * Bei unmap wird ebenfalls (wegen fork) die Prozesskennung benoetigt. */ struct vm_operations_struct { - void (*open)(struct vm_area_struct *, int, void *); - void (*close)(struct vm_area_struct *); - /* void (*unmap)(struct vm_area_struct *, unsigned long, size_t); */ - void (*unmap)(struct vm_area_struct *, - unsigned long, size_t, - struct task_struct *); - void (*protect)(struct vm_area_struct *, unsigned long, size_t, unsigned int); - int (*sync)(struct vm_area_struct *, unsigned long, size_t, unsigned int); - void (*advise)(struct vm_area_struct *, unsigned long, size_t, unsigned int ); - unsigned long (*nopage)(struct vm_area_struct *, unsigned long, int); - unsigned long (*wppage)(struct vm_area_struct *, unsigned long, unsigned long); + void (*open)(struct vm_area_struct * area); + void (*close)(struct vm_area_struct * area); + void (*unmap)(struct vm_area_struct *area, unsigned long, size_t); + void (*protect)(struct vm_area_struct *area, unsigned long, size_t, unsigned int newprot); + int (*sync)(struct vm_area_struct *area, unsigned long, size_t, unsigned int flags); + void (*advise)(struct vm_area_struct *area, unsigned long, size_t, unsigned int advise); + unsigned long (*nopage)(struct vm_area_struct * area, unsigned long address, int write_access); + unsigned long (*wppage)(struct vm_area_struct * area, unsigned long address, + unsigned long page); int (*swapout)(struct vm_area_struct *, unsigned long, pte_t *); pte_t (*swapin)(struct vm_area_struct *, unsigned long, unsigned long); }; -/* Syro : new : Modes fuer den vm_ops-open-call zur Identifizierung - * des Aufrufpunktes. */ - -#define VM_OC_LOCK 1 -#define VM_OC_PROT 2 -#define VM_OC_REMM 3 -#define VM_OC_MUNM 4 -#define VM_OC_FORK 5 -#define VM_OC_COPY 6 -#define VM_OC_NOOP 7 - - /* * Try to keep the most commonly accessed fields in single cache lines * here (16 bytes or greater). This ordering should be particularly @@ -355,8 +259,6 @@ extern int new_page_tables(struct task_struct * tsk); extern int copy_page_tables(struct task_struct * to); -/* Syro : new : free_pte wird anderswo auch gebraucht */ -extern void free_pte(pte_t page); extern int zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size); extern int copy_page_range(struct mm_struct *dst, struct mm_struct *src, struct vm_area_struct *vma); extern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot); @@ -387,8 +289,7 @@ extern void insert_vm_struct(struct mm_struct *, struct vm_area_struct *); extern void remove_shared_vm_struct(struct vm_area_struct *); extern void build_mmap_avl(struct mm_struct *); -/* Syro : new : zusaetzlich task_struct * ... */ -extern void exit_mmap(struct mm_struct *, struct task_struct *); +extern void exit_mmap(struct mm_struct *); extern int do_munmap(unsigned long, size_t); extern unsigned long get_unmapped_area(unsigned long, unsigned long); @@ -412,10 +313,6 @@ #define GFP_LEVEL_MASK 0xf -/* Syro : new : Macro ums einfacher zu machen .... */ -#define OFFSET_GROW(vma, grow) (vma->vm_offset < vma->vm_offset - grow?\ - 0:vma->vm_offset - grow) - /* vma is the first one with address < vma->vm_end, * and even address < vma->vm_start. Have to extend vma. */ static inline int expand_stack(struct vm_area_struct * vma, unsigned long address) @@ -424,38 +321,13 @@ address &= PAGE_MASK; grow = vma->vm_start - address; - /* if (vma->vm_end - address + if (vma->vm_end - address > (unsigned long) current->rlim[RLIMIT_STACK].rlim_cur || (vma->vm_mm->total_vm << PAGE_SHIFT) + grow > (unsigned long) current->rlim[RLIMIT_AS].rlim_cur) - return -ENOMEM; */ - if (vma->vm_end - address - > (unsigned long) current->rlim[RLIMIT_STACK].rlim_cur) { - printk("(%d) Stack-Rlimit violation (%lx)\n", current->pid, - (unsigned long) current->rlim[RLIMIT_STACK].rlim_cur); - return -ENOMEM; - } - if ((vma->vm_mm->total_vm << PAGE_SHIFT) + grow - > (unsigned long) current->rlim[RLIMIT_AS].rlim_cur){ - printk("(%d) AS-Rlimit violation (%lx)\n", current->pid, - (unsigned long) current->rlim[RLIMIT_AS].rlim_cur); return -ENOMEM; - } - /* #define __SYRO */ -#ifdef __SYRO -printk("(%d) expand_stack : change %lx to %lx\noffset : %lx to %lx\n", - current->pid, vma->vm_start, address, - vma->vm_offset, OFFSET_GROW(vma, grow)); -#endif vma->vm_start = address; - vma->vm_rstart = vma->vm_start; /* Syro : new : */ - - /* Syro : new : Hier kommt es sehr oft zu einem Offset-Underflow. - * offset ist ein unsigned long, daher wird kein negativer offset - * erzeugt, sondern ein sehr grosser ??!!. - * Der Wert wird jetzt minimal 0 .... */ - /* vma->vm_offset -= grow; Syro : old .. */ - vma->vm_offset = OFFSET_GROW(vma, grow); + vma->vm_offset -= grow; vma->vm_mm->total_vm += grow >> PAGE_SHIFT; if (vma->vm_flags & VM_LOCKED) vma->vm_mm->locked_vm += grow >> PAGE_SHIFT; @@ -465,31 +337,21 @@ #define avl_empty (struct vm_area_struct *) NULL /* Look up the first VMA which satisfies addr < vm_end, NULL if none. */ -/** Durchsucht den AVL-Baum bzw der virtuellen Speicherbereiche. - ** Es wird solange gesucht bis ein Speicherbereich gefunden wird in dem - ** die angegebene Adresse liegt (addr < vm_end) - ** Achtung : Liefert auch einen VMA retour, wenn addr < vm_start ist; - ** zumindest wird der allerletzte Bereich geliefert, der eigentlich der erste - ** ist (Programm- Name, Umgebung ... und Stack-Start). siehe expand_stack. - **/ static inline struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr) { struct vm_area_struct * result = NULL; if (mm) { struct vm_area_struct * tree = mm->mmap_avl; - for (;;) { /* Durchsuchen des Baumes */ - if (tree == avl_empty) /* Baum-Ende erreicht */ + for (;;) { + if (tree == avl_empty) break; - if (tree->vm_end > addr) { - /* Wenn die Adresse kleiner als das Ende ist, */ - result = tree; /* koennte es passen - */ - /* wenn auch der Anfang vor der Adresse */ - if (tree->vm_start <= addr) /* liegt */ - break; /* Adresse passt ! */ - /* Ansonst weitersuche im linken Ast da */ - tree = tree->vm_avl_left; /* hier kleiner */ - } else /* Rechter Ast da alles zu klein .. */ + if (tree->vm_end > addr) { + result = tree; + if (tree->vm_start <= addr) + break; + tree = tree->vm_avl_left; + } else tree = tree->vm_avl_right; } } @@ -508,48 +370,6 @@ return vma; } -/* Syro : new : - * Macros fuer Pipe-mmap - */ -/* Der folgende Text stimmt nicht mehr !!!! */ -/* Um eine eindeutige Zuordnung von VMA und read/write-Pipe zu erreichen, - * wird eine zusaetzliche Information benoetigt. Der VMA verweist nur auf - * eine Inode und diese repraesentiert aber beide Pipe-Auspraegungen. !! - * Da die VMA stucture eine spezielle Komponente enthaelt, die nur fuer die - * SHM-Implementierung gebraucht wird, kann dieser Eintrag fuer die - * Pipe-Implementierung adaptiert werden. Dabei handelt es sich um die - * Komponente vm_pte, die die Liste der PageTableEntries des SHM - * beinhaltet. - * Um moeglichst alle Informationen zur Pipe-Einblendung direkt zugaenglich - * zu haben, wird in dieser Komponente ein Zeiger auf den zugehoerigen - * Mapper-Entry abgelegt. - * Fuer dem Pipe-Mode-Indikator wird vm_next_share verwendet. - * Eine Eigenschaft der eingeblendeten Pipe ist die Auto-Commit-Faehigkeit. - * Darunter versteht man die Moeglichkeit, festzulegen, dass bei einer - * bestimmten Groesse des tatsaechlich eingeblendeten Buffers selbsttaetig - * ein commit ausgefuehrt wird. Diese Information soll nicht ein allgemeines - * Attribut einer Pipe sein, sondern soll individuell an die Einblendung, also - * an den VMA gebunden sein. Damit ist es aber auch notwendig diese Information - * in der VMA Beschreibung abzulegen. Es besteht zwar ein 1:1 Zusammenhang - * zwischen VMA und Mapper-Entry, aber im Falle von Teilungen von VMAs im - * Zuge der diversen VMA-Operationen (mremap, munmap, mprotect, ....) - * kann dieser in der aufgerufenen pipemap_open()-Funktion nicht mehr - * rekonstruiert werden (man weiss nicht aus welchen VMA der neue Eintrag - * der als Parameter uebergeben wird, entstanden ist). - * Der Auto-Commit-Indikator wird in vm_prev_share abgelegt. Dabei bedeutet - * der Wert 0 dass kein auto-commit erfolgen soll (default). Ansonsten wird - * die Groesse bei der das commit erfolgen soll abgelegt. - */ - -#define VM_RD_PIPE ((int) 0) -#define VM_WR_PIPE ((int) 1) -#define VM_PIPE_NOAUTO ((unsigned long) 0) - -/* Pointer auf den Mapper-Entry in der Mapperliste der Pipe-Inode */ -#define VMA_PMAP(vma) ((struct pipe_mapper *) vma->vm_pte) - #endif /* __KERNEL__ */ #endif - -#undef __SYRO --- /usr/src/linux-work/include/linux/sched.h Thu Mar 9 14:37:29 2000 +++ /usr/src/linux/include/linux/sched.h Tue Apr 4 17:24:42 2000 @@ -137,9 +137,6 @@ NULL, NULL \ } -/** Zu jedem Prozess werden die n"otigen Daten zur Speicherverwaltung in - ** dieser Unterstruktur zusammengefasst. - **/ struct mm_struct { int count; pgd_t * pgd; @@ -147,20 +144,11 @@ unsigned long start_code, end_code, start_data, end_data; unsigned long start_brk, brk, start_stack, start_mmap; unsigned long arg_start, arg_end, env_start, env_end; - /** total_vm : scheint die Gesamtgr"osse des virtuellen Speichers in - ** Pages (wenn vm_end - vm_start nicht ganzzahlig teilbar durch die - ** Pagesize ist, dann um eine weniger !) zu sein. - **/ unsigned long rss, total_vm, locked_vm; - unsigned long def_flags; - /** Die zum Prozess geh"orenden Mappings werden in verschiedenen Formen - ** zug"anglich gemacht. Einmal durch eine einfach verkettete Liste, die - ** nach den Adressen sortiert ist und durch einen ebenso sortierten - ** AVL-Baum. (VMA-Liste) - **/ - struct vm_area_struct * mmap; /* einfach verkettete Liste */ - struct vm_area_struct * mmap_avl; /* AVL-Baum */ - struct semaphore mmap_sem; /* Semaphore zum Sperren der VMA_Liste */ + unsigned long def_flags; + struct vm_area_struct * mmap; + struct vm_area_struct * mmap_avl; + struct semaphore mmap_sem; }; #define INIT_MM { \ --- /usr/src/linux-work/include/linux/stat.h Sun Feb 21 18:04:12 1999 +++ /usr/src/linux/include/linux/stat.h Sat Jun 10 17:36:07 1995 @@ -7,10 +7,8 @@ #endif -/* inode flags und macros um diese zu "uberpr"ufen. */ - -#define S_IFMT 00170000 /* Bitmaske f"ur Flags-Test in den Macros. */ -#define S_IFSOCK 0140000 /* Inode beschreibt einen Socket ... */ +#define S_IFMT 00170000 +#define S_IFSOCK 0140000 #define S_IFLNK 0120000 #define S_IFREG 0100000 #define S_IFBLK 0060000 @@ -20,13 +18,6 @@ #define S_ISUID 0004000 #define S_ISGID 0002000 #define S_ISVTX 0001000 - -/* Macros um das Vorhandensein der diversen Flags zu pr"ufen. - * S_ISREG : Regul"ares File; dieser Test wird oft verwendet, um fstzustellen - * ob es sich um eine normale Datei hanelt; dabei wird als m die - * st_mode-Komponente der stat-Struktur (fstat()-call) verwendet. - * -auch wenn in der Beschreibung steht, dass das die Protection ist. - */ #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK) #define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) --- /usr/src/linux-work/include/linux/pipe_fs_i.h Thu Mar 9 14:35:06 2000 +++ /usr/src/linux/include/linux/pipe_fs_i.h Tue Mar 12 15:08:22 1996 @@ -1,384 +1,35 @@ #ifndef _LINUX_PIPE_FS_I_H #define _LINUX_PIPE_FS_I_H -/* Syro new : */ - -#define ALL_PD 9 /* nur in der extrem-Diagnose */ -#define LOW_PD 7 /* seltener */ -#define HIGH_PD 5 /* heufiger */ -#define MAP_PD 3 /* immer wenn Pipe gemapped */ -#define NORM_PD 2 -#define INIT_PD 1 -#define NO_PD 0 - -/* Pipe-Modi stehen auch dem User zur Verfuegung. */ -#define NORM_PIPE 0 /* Wird direkt boolsch abgefragt !! */ -#define MAP_PIPE 1 -#define MTON_PIPE 2 - -#ifdef __KERNEL__ - -#include - -/** Syro : Working .... **/ -/* Achtung :: Der Trick mit &Groesse-1 als Modulo-Ersatz geht nur wenn - * Groesse eine Zweierpotenz ist !! */ - -/* Groesse bis zu der der Buffer maximal anwachsen koennen soll. - * ACHTUNG : MUSS eine 2er-Potenz sein (wegen & val-1 Operationen) - * minimal 8 !!!*/ - -#define DEFAULT_BUF_PAGES 128 -#define DEFAULT_BUF_SIZE (PAGE_SIZE * DEFAULT_BUF_PAGES) -/* Wert der bei der Preufung ob auto-commit noetig ist zu PM_AUTO - * addiert wird um die Granularitaet zu verringern. - * Muss auf DEFAULT_BUF_PAGES abgestimmt sein. - */ -#define AUTO_STEP (((DEFAULT_BUF_PAGES <= 32)?3:6) * PAGE_SIZE) - -/* Defaultwert, der beim mmap()-Aufruf als einzublendende Groesse - * angegeben werden kann .... */ -#define PIPE_MMAP_SIZE (DEFAULT_BUF_SIZE * 1024) - -/* mpipe_commit Aufrufmodi. */ -# define PM_SYNC_MODE 0 -# define PM_UNMAP_MODE 1 - - -/* Struktur, die prozessbezogene Informationen zur Einblendung - * beinhaltet. act_pos ist ein Offset-Wert in der Pipe; je nach Verwendung - * handelt es sich um die prozessbezogene Lese- oder Schreib-Position. - * rel_len gibt an, bei welcher Groesse des geschriebenen/gelesenen Bereiches - * dieser selbsttaetig freigegeben wird (Auto-Release); - * vma_start : zur Identifizierung des richtigen VMAs falls die Pipe von - * diesem Prozess oeffters eingeblendet wird. Allerdings muss der Erhalt des - * VMAs gesichert sein. Er darf nicht mit anderen durch ein Merge zusammen- - * gelegt werden. Zusaetzliche Abfrage in merge_segments() / mm/mmap.c. */ - -struct pipe_mapper { - struct task_struct * task; /* Prozess-ID */ - unsigned long flag; /* READ oder WRITE Mapper/VMA, SIG usw */ - unsigned long vma_start; /* Anfang (vm_start) des Pipe-VMA's */ - unsigned long act_pos; /* Lese/Schreib-Position */ - unsigned long rel_len; /* Auto-Release-Laenge */ - struct pipe_mapper * next; -}; - -/* Positionen der Flags in der flag Komponente */ -#define PM_MODE_MASK 0x1 /* Position 1 (von links) */ -#define PM_SIG_MASK 0x2 /* Pos 2,3,4 fuer gesendete Signale */ -#define PM_SIG_PIPE 0x2 /* PIPE-Signal gesetzt */ - - -/* Macros fuer den Zugriff auf die Mapper-Entries ... - * Am Ende der Datei gibts noch mehr davon - fuer komplexere Aufgaben */ - -#define PM_TASK(pmp) ((pmp)->task) -#define PM_PID(pmp) ((pmp)->task->pid) -#define PM_START(pmp) ((pmp)->vma_start) /* vma->vm_start */ -#define PM_POS(pmp) ((pmp)->act_pos) -#define PM_FLAG(pmp) ((pmp)->flag) -#define PM_MODE(pmp) ((pmp)->flag & PM_MODE_MASK) -#define PM_SIG(pmp) ((pmp)->flag & PM_SIG_MASK) -#define PM_AUTO(pmp) ((pmp)->rel_len) - -#define PM_SIGPIPE(pmp) (PM_SIG(pmp) & PM_SIG_PIPE) - -/* PM_MODE wird mit den Werten VM_RD_PIPE (1) und VM_WR_PIPE (0) die in - * mm.h definiert sind initialisiert; daher kann man den Wert auch als - * bit-Flag abfragen ... */ - -struct pbpage { - unsigned int ppflags; - pte_t ppte; /* new : Page-Table-Entry des Buffers */ -}; - -#define PBF_INIT 0x0 -#define PBF_USED 0x1 -#define PBF_SYNC 0x2 - -#define MPIPE_PTE(ppage) ((ppage).ppte) -#define MPIPE_PFLAGS(ppage) ((ppage).ppflags) - -#define pb_init(ppage) (MPIPE_PFLAGS(ppage) = PBF_INIT) -#define pb_set(ppage, flag) (MPIPE_PFLAGS(ppage) = flag) -#define pb_add(ppage, flag) (MPIPE_PFLAGS(ppage) |= flag) -#define pb_clear(ppage, flag) (MPIPE_PFLAGS(ppage) &= ~flag) -#define pb_use(ppage) (pb_add(ppage, PBF_USED)) -#define pb_unuse(ppage) (pb_clear(ppage, PBF_USED)) -#define pb_sync(ppage) (pb_add(ppage, PBF_SYNC)) -#define pb_nosync(ppage) (pb_clear(ppage, PBF_SYNC)) - - struct pipe_inode_info { - unsigned int mode; /* new : Modus der Pipe (normal/map) */ - struct wait_queue * wait; /* Warteschlange */ - char * base; /* Adresse des Pipe-Puffers (normal) */ - /* Bei der eingeblendeten Pipe ist dieser Wert (base) immer die Anfangs- - * adresse der ersten Seite des Pipe-Buffers. Wenn der Buffer gerade - * nicht in den Kerneladressraum eingeblendet ist, ist dieser Wert NULL. */ - unsigned long start; /* Aktueller Bereich Anfang; (normal) */ - unsigned long wstart; /* Schreibbereich Anfang (write) */ - unsigned long len; /* Aktueller Bereich Laenge (long new) */ - unsigned int lock; /* Sperren */ - unsigned int rd_openers; /* Anz. der Proz. die zum Lesen oeffnen */ - unsigned int wr_openers; /* Anz. d. Proz. d. zum Schreiben oeffnen */ - unsigned int readers; /* Anz. der in Moment lesenden Proz. */ - unsigned int writers; /* Anz. der in Moment schreibenden Proz. */ - unsigned long bufsize; /* new : Groesse des Pipe-Buffers */ - unsigned long map_base; /* new : Absoluter Offset der m-Pipe */ - unsigned long map_start; /* new : Start-Offset der m-Pipe */ - struct pbpage *page_list; /* new : Page-Liste des Buffers */ - struct pipe_mapper * rmap; /* new : Listen der Prozesse die zum */ - struct pipe_mapper * wmap; /* Lesen/Schreiben eingeblendet haben */ - unsigned int dlevel; /* Diagnoselevel der Pipe */ + struct wait_queue * wait; + char * base; + unsigned int start; + unsigned int len; + unsigned int lock; + unsigned int rd_openers; + unsigned int wr_openers; + unsigned int readers; + unsigned int writers; }; -/* Begriffe : - * Bufferoffset : Offset im zum Zeitpunkt zugaenglichen Buffer; - * Pipe-Offset, absoluter Offset : Offset in Bezug auf den Anfang der - * Pipe. - * MPIPE_BASE : ist der Anfang des Buffers; ist also ein Pipe-Offset - - * und stellt immer den Bufferoffset 0 dar. - */ - -/* Darstellung der eingeblendeten Pipe : - * Lebenszeit : Wenn eine Umstellung vom Normal- in den Map-Mode erfolgt, - * beginnt die Lebenszeit (=Offset-Zaehlung). Sie endet, wenn kein Prozess - * mehr die Pipe eingeblendet hat und eine Rueckstellung in den Normal-Mode - * erfolgen kann. - * Die eingeblendete Pipe wird durch folgende Werte dargestellt : - * pte_list : Liste der verwendeten Speicherseiten des Buffers - * bufsize : Buffergroesse in Bytes; daraus laesst sich die aktuelle, - * maximale Groesse der pte_list errechnen (bufsize / PAGE_SIZE) - * Enthaelt auch bei der Normal-Mode-Pipe die Buffergroesse. - * map_base : aktueller Offset an dem der Buffer beginnt; entspricht also - * der Anfangsadresse der Page, die gerade durch pte_list[0] - * referenziert wird. Liegt immer auf einer Seitengrenze. - * Dient eigentlich nur der internen Verwaltung. MPIPE_BASE(). - * map_start : Der tatsaechliche Anfang des Buffers. Ist also zu jedem - * Zeitpunkt eine Adresse in der ersten Seite. Es ist ein Offset - * in Bezug auf map_base; um den Offset im Buffer zu erhalten - * muss er zu map_base addiert werden. - * rmap,wmap : Liste der Mapper-Entries. Je eine Liste f"ur die Lese- und - * Schreib-einblendungen. - * Zu einem gegebenen Zeitpunkt gibt map_base den Offset der ersten, noch - * zugreifbaren Seite an. map_start ist der Offset des tatsaechlichen Buffer- - * anfangs in dieser Seite. Aus diesem Wert werden mit Hilfe diverser Macros - * alle weiteren Werte berechnet. Der Anfang des Lesebereiches ist gleich dem - * Buffer-Start; der Anfang des Schreibbereiches ist dieser Wert plus der - * aktuellen Laenge len. Wobei je ein Macropaar fuer die Buffer-Offsets (in - * bezug auf map_base) und die Pipe-Offsets (fuer die Rueckgabe durch ioctl()) - * definiert sind. - * Zum Einblenden muss ein Prozess den Offset ab den die Einblendung - * erfolgen soll, angeben. Er erhaelt diese Werte durch einen ioctl()-Aufruf. - * Dieser Wert muss groesser/gleich dem aktuellen Bufferanfang sein. - * Dieser Pipe-Offset wird als prozessbezogener Anfangswert in die act_pos- - * Komponente des Mapper-Entries eingetragen. Ueber diesen Wert muss die - * Verbindung zwischen den VMA-Adressen und den Buffer-Offsets hergestellt - * werden. - * Zusammenhang : act_pos gibt den absoluten Offset in der Pipe an. Dieser - * Wert in bezug auf die Seitengroesse gibt den Offset in der ersten Seite - * des VMAs an. Zum Zeitpunkt des Einblendens konnte diese erste Seite des - * VMAs ja eine beliebige in der PTE-Liste gewesen sein, daher act_pos als - * Absolutoffset. Zu einer Adresse im VMA wird die Differenz zum Anfang des - * VMAs berechnet (zur Zeit muss das noch der Beginn der ersten Seite sein, - * wenn die VMA-Verwaltung erweitert wurde, sind beliebige Offsets moeglich) - * Dieser Wert wird zu act_pos addiert und ergibt die absolute Position in - * der Pipe. Vermindert um den Wert von map_base erhaelt man den Offset im - * Buffer. Der Index in der PTE-Liste erhaelt man durch die Teilung mit der - * Seitengroesse PAGE_SIZE. Der Offset innerhalb der Seite kann durch die - * &PAGE_MASK-Operation berechnet werden. - * - */ - -/* Zugriff auf die Pipe im mmap-Modus ueber read/write : - * start (NPIPE_START bzw NPIPE_RSTART) gibt den Anfang des Lesebereiches - * als Total-Offset im Buffer an. Um den Offset in Bezug auf den zum - * gegebenen Zeitpunkt tatsaechlich zugreifbaren Buffer zu erhalten (um zb. - * den Index der betreffenden Speicherseite im PTE-Array zu bestimmen), muss - * der Wert um MPIPE_BASE reduziert werden. - * Direkter Zugriff : MPIPE_START ist anders als NPIPE_START immer der - * Offset in der ersten Seite; um den zu NPIPE_START aequivalenten Wert zu - * erhalten muss man MPIPE_BASE dazugeben ! - */ - -#define PIPE_MODE(inode) ((inode).u.pipe_i.mode) +#define PIPE_WAIT(inode) ((inode).u.pipe_i.wait) #define PIPE_BASE(inode) ((inode).u.pipe_i.base) -#define MPIPE_BASE(inode) ((inode).u.pipe_i.map_base) -#define MPIPE_PLIST(inode) ((inode).u.pipe_i.page_list) -#define MPIPE_START(inode) ((inode).u.pipe_i.map_start) -#define NPIPE_START(inode) ((inode).u.pipe_i.start) -#define NPIPE_RSTART(inode) NPIPE_START(inode) -#define NPIPE_WSTART(inode) ((inode).u.pipe_i.wstart) -#define PIPE_START(inode) (PIPE_MODE(inode)?MPIPE_START(inode):\ - NPIPE_START(inode)) +#define PIPE_START(inode) ((inode).u.pipe_i.start) #define PIPE_LEN(inode) ((inode).u.pipe_i.len) -/* New : Die Groesse der Pipe ist jetzt in einer Komponente der Pipe- - * Struktur gespeichert. Sie ist im Normalfall mit PIPE_BUF initialisiert; - * beim Einblenden wird der Wert DEFAULT_BUF_SIZE initialisiert. */ -#define PIPE_BUF_SIZE(inode) ((inode).u.pipe_i.bufsize) -#define AUTO_SIZE(inode) (((PIPE_BUF_SIZE(inode) / 10) & PAGE_MASK)+PAGE_SIZE) -#define PIPE_BUF_PAGES(inode) (((inode).u.pipe_i.bufsize) >> PAGE_SHIFT) -#define MPIPE_BUF_END(inode) (PIPE_BUF_SIZE(inode) + MPIPE_BASE(inode)) -/* Virtuelle Adressen fuer den Begin des Lese- und Schreibbereiches; - * Wenn die eingeblendete Pipe nicht im Kernelsegment eingeblendet ist, - * dann entsprechen diese Werte den Offset-Werten. */ -#define MPIPE_RSTART(inode) (MPIPE_START(inode)) -#define MPIPE_WSTART(inode) (MPIPE_START(inode)+PIPE_LEN(inode)) -/* Offset-Werte in Bezug auf den absoluten Anfang der eingeblendeten Pipe - * fuer den Lese-/Schreib-Bereich. - * Diese Werte sollen von ioctl() geliefert werden. */ -#define MPIPE_ROFF(inode) (MPIPE_BASE(inode) + MPIPE_RSTART(inode)) -#define MPIPE_WOFF(inode) (MPIPE_BASE(inode) + MPIPE_WSTART(inode)) - -#define MPIPE_READERS(inode) ((inode).u.pipe_i.rmap) -#define MPIPE_WRITERS(inode) ((inode).u.pipe_i.wmap) - -#define PIPE_WAIT(inode) ((inode).u.pipe_i.wait) -/* new : PIPE_START ersetzt ... - #define PIPE_START(inode) ((inode).u.pipe_i.start) */ #define PIPE_RD_OPENERS(inode) ((inode).u.pipe_i.rd_openers) #define PIPE_WR_OPENERS(inode) ((inode).u.pipe_i.wr_openers) #define PIPE_READERS(inode) ((inode).u.pipe_i.readers) #define PIPE_WRITERS(inode) ((inode).u.pipe_i.writers) #define PIPE_LOCK(inode) ((inode).u.pipe_i.lock) +#define PIPE_SIZE(inode) PIPE_LEN(inode) -/* Wenn MPIPE_WOFF und NPIPE_START gleich sind, muss die Berechnung - * von PIPE_SIZE korrigiert werden, da ansonst ein negativer Wert kommt */ -#define SIZE_KORR(inode) ((MPIPE_WOFF(inode) & PAGE_MASK)>NPIPE_START(inode)?\ - (MPIPE_WOFF(inode) & PAGE_MASK) - NPIPE_START(inode):\ - 0) -#define PIPE_SIZE(inode) (PIPE_MODE(inode)?SIZE_KORR(inode):\ - PIPE_LEN(inode)) -#define PIPE_RSIZE(inode) (PIPE_MODE(inode)?\ - NPIPE_WSTART(inode) - NPIPE_START(inode):\ - PIPE_LEN(inode)) - /* Zeigt an, dass keine Daten fuer read() in der Pipe sind (deshalb - * muss aber der Pipe-Buffer nicht leer sein => MPIPE_EMPTY */ #define PIPE_EMPTY(inode) (PIPE_SIZE(inode)==0) - /* MPIPE_EMPTY zeigt an, dass der Pipe-Buffer leer ist. */ -#define MPIPE_EMPTY(inode) (PIPE_LEN(inode)==0) - -#define PIPE_FULL(inode) (PIPE_SIZE(inode)==PIPE_BUF_SIZE(inode)) -/* Verhinderung von negativen Groessenwerten. */ -#define FSUB_VAL(inode) (PIPE_MODE(inode)?\ - (NPIPE_WSTART(inode) - MPIPE_BASE(inode)):\ - PIPE_LEN(inode)) -#define PIPE_FREE(inode) ((PIPE_BUF_SIZE(inode) > FSUB_VAL(inode))?\ - (PIPE_BUF_SIZE(inode) - FSUB_VAL(inode)):0) - /* Syro :: hier das end -problem .... */ +#define PIPE_FULL(inode) (PIPE_SIZE(inode)==PIPE_BUF) +#define PIPE_FREE(inode) (PIPE_BUF - PIPE_LEN(inode)) #define PIPE_END(inode) ((PIPE_START(inode)+PIPE_LEN(inode))&\ - (PIPE_BUF_SIZE(inode)-1)) - -/* Maximaler Platz bis zum Bufferende, bzw Seitenende. - * Dieser Platz muss aber nicht zur Gaenze frei sein ! */ -#define PIPE_MAX_WCHUNK(inode) (PIPE_BUF - (NPIPE_WSTART(inode) % PIPE_BUF)) -#define PIPE_MMAX_WCHUNK(inode) (PAGE_SIZE - (NPIPE_WSTART(inode) % PAGE_SIZE)) - -#define PIPE_MAX_RCHUNK(inode) (PIPE_BUF - (NPIPE_START(inode) % PIPE_BUF)) -#define PIPE_MMAX_RCHUNK(inode) (PAGE_SIZE - (NPIPE_RSTART(inode) % PAGE_SIZE)) - - -/* Syro : Neu New */ -/* Angepasste Offset-Werte fuer die Normal-Modus Pipe. Wenn Daten in der - * Pipe sind, dann werden sie Endbuendig angeordnet. */ -#define PIPE_ROFF(inode) (PIPE_EMPTY(inode) ? 0:\ - (PIPE_BUF_SIZE(inode) - PIPE_LEN(inode))) -#define PIPE_WOFF(inode) (PIPE_EMPTY(inode)?0:PIPE_BUF_SIZE(inode)) -#define MPIPE_EOFF(inode) (PIPE_END(inode) + MPIPE_BASE(inode)) - -/* Syro : New - Neu */ -/* Anzahl der Seiten die der Pipe-Buffer im Normalfall einnimmt. - * Die Groesse kann nur ein ganzzahliges Vielfaches der Page-Groesse sein. - * FULL_PAGES gibt die Anzahl der belegten Pages an; ACHTUNG : dem Makro - * darf nur ein Wert > 0 uebergeben werden */ - -#define FULL_PAGES(len) ((len % PAGE_SIZE) ? (len / PAGE_SIZE) + 1 : \ - (len / PAGE_SIZE)) -/* Liefert den letzten PTE in der Buffer-Liste. Wird gebraucht um - * festzustellen, ob ein Prozess - theoretisch - aufs Weiterschreiben wartet.*/ -#define LAST_PTE(inode) (MPIPE_PTE(MPIPE_PLIST(inode)[\ - (PIPE_BUF_SIZE(inode)>>PAGE_SHIFT)-1])) -#define LAST_PBPAGE(inode) (MPIPE_PLIST(inode)[\ - (PIPE_BUF_SIZE(inode)>>PAGE_SHIFT)-1]) -/* More Mapper-Entry-Macros ... */ -/* PM_ADDR gibt zu einem VMA_OFF (Offset zu vm_rstart im VMA) den - * entsprechenden absoluten Offset in der Pipe an (nicht zum aktuellen - * Bufferanfang sondern zum absoluten Pipe-Anfang); act_pos beschreibt ja - * einen beliebigen Offset. */ -#define PM_ADDR(pmp, off) ((pmp)->act_pos + off) -/* PM_BOFF gibt zu einem VMA_OFF den entsprechenden aktuellen Buffer- - * offset zurueck. */ -#define PM_BOFF(inode, pmp, off) (PM_ADDR(pmp, off) - MPIPE_BASE(*inode)) -/* Berechnet zu einem aktuellen Buffer-Offset den Seitenindex in der - * PTE-Liste */ -#define PM_PTEIDX(boff) ((int) ((boff) / PAGE_SIZE)) -/* Gibt zu einem Bufferoffset den Offset der Page in der der Wert liegt an */ -#define PM_POFF(boff) (boff & PAGE_MASK) - - /* Diagnose - Sachen */ - - -#define PIPE_DLEV(inode) ((inode).u.pipe_i.dlevel) - -#define __NORM(inode) ((inode).i_pipe?(PIPE_DLEV(inode) >= NORM_PD):0) -#define __MAP(inode) ((inode).i_pipe?(PIPE_DLEV(inode) >= MAP_PD):0) -#define __LOW(inode) ((inode).i_pipe?(PIPE_DLEV(inode) >= LOW_PD):0) -#define __HIGH(inode) ((inode).i_pipe?(PIPE_DLEV(inode) >= HIGH_PD):0) -#define __ALL(inode) ((inode).i_pipe?(PIPE_DLEV(inode) >= NO_PD):0) - - - - /* Ende des __KERNEL__ if */ -#endif - - /* Syro : new : - * Definitionen die der User fuer das Pipe-mmap braucht. - * Wird ueber mman.h inkludiert. - */ - -struct pstat_struct { - unsigned long addr; /* Adresse im betroffenen VMA. */ - char mode; /* Aktueller Mode der Pipe . */ - unsigned long sec_rbuf; /* relativer zugreifbarer (read-) Buffer. */ - unsigned long tot_rbuf; /* relativer (read-) Buffer gesamt. */ - unsigned long bsize; /* Pipe-Buffer gesamt. */ - unsigned long vmstart; /* Aktueller Bereichsanfang. */ - unsigned long io_pos; /* I/O Position im Buffer. */ - unsigned long updsize; /* Auto-commit Groesse. */ - int sigflag; /* Signal an die Einblendung. */ - int readers; /* Anzahl der Leser. */ - int writers; /* Anzahl der Schreiber. */ -}; - - /* ioctl Operationen */ -/* Aktueller Modus der Pipe */ -#define PM_PMODE 0x00004400 -/* Aktueller Offset in der Pipe; je nachdem ob das Lese- oder Schreibende - * der Pipe angegeben wurde, wird der Schreib- oder der Lese-Offset - * geliefert. Diese Werte werden gebraucht, um sie beim mmap()-call - * anzugeben. */ -#define PM_BUFOFF 0x00004401 -/* Mit diesem Aufruf koennen einige Werte zur Pipe abgefragt werden. - * Wichtig fuer lesende Prozesse, die die Groesse des aktuell tatsaechlich - * zugreifbaren Buffers auslesen wollen. */ -#define PM_GETSTAT 0x00004405 -#define PM_SETUPDSIZE 0x00004413 - -#define PM_GETBUFSIZE 0x00004404 -#define PM_SETBUFSIZE 0x00004414 /* nur root */ - -#define PM_DLEV 0x00004498 /* nur fuer Diagnose-Zwecke */ -#define PM_DIAG 0x00004499 /* nur fuer Diagnose-Zwecke */ - + (PIPE_BUF-1)) +#define PIPE_MAX_RCHUNK(inode) (PIPE_BUF - PIPE_START(inode)) +#define PIPE_MAX_WCHUNK(inode) (PIPE_BUF - PIPE_END(inode)) #endif - - - - - - - - --- /usr/src/linux-work/include/linux/resource.h Sun Feb 21 18:04:13 1999 +++ /usr/src/linux/include/linux/resource.h Tue Jul 2 18:11:31 1996 @@ -39,19 +39,9 @@ #define RLIM_INFINITY ((long)(~0UL>>1)) -/** - ** F"ur eine Resource gibt es zwei Grenzwerte : rlim_cur - der aktuele - ** Wert, das Softlimit, und rlim_max - der maximal m"ogliche Wert, das - ** Hardlimit. Diese Werte k"onnen mit den Limit-Syscalls getrlimit/setrlimit - ** und getrusage manipuliert werden. Dabei gilt : das Softlimit kann maximal - ** bis zum Hardlimit erh"oht werden; es kann aber auch wieder verringert - ** werden. Das Hardlimit kann nicht erh"oht werden. Es kann bis zum Soft- - ** limit verringert werden. Das allerdings nur einmal ! - **/ - struct rlimit { - long rlim_cur; /* Softlimit */ - long rlim_max; /* Hardlimit */ + long rlim_cur; + long rlim_max; }; #define PRIO_MIN (-20) --- /usr/src/linux-work/include/linux/limits.h Sat Feb 20 17:37:18 1999 +++ /usr/src/linux/include/linux/limits.h Wed Jul 17 14:10:03 1996 @@ -12,9 +12,6 @@ #define MAX_INPUT 255 /* size of the type-ahead buffer */ #define NAME_MAX 255 /* # chars in a file name */ #define PATH_MAX 1024 /* # chars in a path name */ -/* SYRO Pipe soll gr"osser sein ... */ -#define PIPE_ORD 0 -/* #define PIPE_BUF 4096 # bytes in atomic write to a pipe */ -#define PIPE_BUF (4096 << PIPE_ORD) /* # bytes in atomic write to a pipe */ +#define PIPE_BUF 4096 /* # bytes in atomic write to a pipe */ #endif --- /usr/src/linux-work/include/asm/page.h Wed Apr 28 22:40:34 1999 +++ /usr/src/linux/include/asm/page.h Thu Nov 30 13:12:41 1995 @@ -51,7 +51,6 @@ #endif /* to align the pointer to the (next) page boundary */ -/* legt den Wert fuer addr auf die naechste Seitengrenze */ #define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK) /* This handles the memory map.. */ @@ -61,27 +60,3 @@ #endif /* __KERNEL__ */ #endif /* _I386_PAGE_H */ - - - - - - - - - - - - - - - - - - - - - - - - --- /usr/src/linux-work/include/asm/processor.h Sat Mar 20 14:05:50 1999 +++ /usr/src/linux/include/asm/processor.h Sun Nov 15 19:33:15 1998 @@ -161,10 +161,8 @@ unsigned long screen_bitmap; unsigned long v86flags, v86mask, v86mode; }; -/* SYRO : new : */ -/* #define INIT_MMAP { &init_mm, 0, 0x40000000, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC } */ - #define INIT_MMAP { &init_mm, 0, 0, 0x40000000, 0x40000000, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC } +#define INIT_MMAP { &init_mm, 0, 0x40000000, PAGE_SHARED, VM_READ | VM_WRITE | VM_EXEC } #define INIT_TSS { \ 0,0, \ --- /usr/src/linux-work/include/asm/mman.h Sun Jan 23 19:10:40 2000 +++ /usr/src/linux/include/asm/mman.h Mon Dec 11 08:06:30 1995 @@ -8,8 +8,6 @@ #define MAP_SHARED 0x01 /* Share changes */ #define MAP_PRIVATE 0x02 /* Changes are private */ -#define MAP_RDSTREAM 0x04 /* Mapping of Read-Stream */ -#define MAP_WRSTREAM 0x08 /* Mapping of Write-Stream */ #define MAP_TYPE 0x0f /* Mask for type of mapping */ #define MAP_FIXED 0x10 /* Interpret addr exactly */ #define MAP_ANONYMOUS 0x20 /* don't use a file */