Return to 9.i CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests

Annotation of researchv10no/cmd/ccom/vax/tests/9.i, revision 1.1

1.1     ! root        1: /* vmmem.c */
        !             2: typedef        unsigned char   u_char;
        !             3: typedef        unsigned short  u_short;
        !             4: typedef        unsigned int    u_int;
        !             5: typedef        unsigned long   u_long;
        !             6: typedef        struct  _physadr { int r[1]; } *physadr;
        !             7: typedef        int     daddr_t;
        !             8: typedef        char *  caddr_t;
        !             9: typedef        u_short ino_t;
        !            10: typedef        int     swblk_t;
        !            11: typedef        int     size_t;
        !            12: typedef        int     time_t;
        !            13: typedef        int     label_t[14];
        !            14: typedef        short   dev_t;
        !            15: typedef        int     off_t;
        !            16: typedef long   portid_t;
        !            17: typedef struct fd_set { int fds_bits[1]; } fd_set;
        !            18: int    hz;                     
        !            19: int    timezone;               
        !            20: int    dstflag;                
        !            21: char   canonb[256              ];      
        !            22: extern char    version[];              
        !            23: int    lbolt;                  
        !            24: time_t time;                   
        !            25: time_t bootime;                
        !            26: long   trannum;                
        !            27: int    hand;                   
        !            28: int    nblkdev;
        !            29: int    nchrdev;
        !            30: int    nstream;                
        !            31: int    nswdev;                 
        !            32: int    mpid;                   
        !            33: char   runin;                  
        !            34: char   runout;                 
        !            35: int    runrun;                 
        !            36: char   kmapwnt;                
        !            37: char   curpri;                 
        !            38: int    maxmem;                 
        !            39: int    physmem;                
        !            40: int    nswap;                  
        !            41: int    updlock;                
        !            42: daddr_t        rablock;                
        !            43: extern int intstack[];         
        !            44: dev_t  rootdev;                
        !            45: dev_t  dumpdev;                
        !            46: long   dumplo;                 
        !            47: dev_t  swapdev;                
        !            48: dev_t  argdev;                 
        !            49: dev_t  pipedev;                
        !            50: extern int icode[];            
        !            51: extern int szicode;            
        !            52: dev_t  getmdev();
        !            53: daddr_t        bmap();
        !            54: caddr_t        calloc();
        !            55: unsigned max();
        !            56: unsigned min();
        !            57: int    memall();
        !            58: int    uchar(), schar();
        !            59: int    vmemall();
        !            60: char   *wmemall();
        !            61: swblk_t        vtod();
        !            62: extern struct sysent
        !            63: {
        !            64:        int     sy_narg;                
        !            65:        int     (*sy_call)();           
        !            66: } sysent[];
        !            67: extern char    vmmap[];                
        !            68: int    umbabeg,umbaend;        
        !            69: int    noproc;                 
        !            70: extern int catcher[256];
        !            71: char   *panicstr;
        !            72: int    wantin;
        !            73: int    boothowto;              
        !            74: struct pte
        !            75: {
        !            76: unsigned int   pg_pfnum:21,            
        !            77:                :2,
        !            78:                pg_vreadm:1,            
        !            79:                pg_swapm:1,             
        !            80:                pg_fod:1,               
        !            81:                pg_m:1,                 
        !            82:                pg_prot:4,              
        !            83:                pg_v:1;                 
        !            84: };
        !            85: struct hpte
        !            86: {
        !            87: unsigned int   pg_pfnum:21,
        !            88:                :2,
        !            89:                pg_high:9;              
        !            90: };
        !            91: struct fpte
        !            92: {
        !            93: unsigned int   pg_blkno:20,            
        !            94:                pg_fileno:5,            
        !            95:                pg_fod:1,               
        !            96:                :1,
        !            97:                pg_prot:4,
        !            98:                pg_v:1;
        !            99: };
        !           100: struct pte *vtopte();
        !           101: extern struct pte Sysmap[];
        !           102: extern struct pte Usrptmap[];
        !           103: extern struct pte usrpt[];
        !           104: extern struct pte Swapmap[];
        !           105: extern struct pte Forkmap[];
        !           106: extern struct pte Xswapmap[];
        !           107: extern struct pte Xswap2map[];
        !           108: extern struct pte Pushmap[];
        !           109: extern struct pte Vfmap[];
        !           110: extern struct pte mmap[];
        !           111: extern struct pte msgbufmap[];
        !           112: extern struct pte camap[];
        !           113: extern struct pte Nexmap[][16];
        !           114: extern struct pte Prusrmap[];
        !           115: struct cmap
        !           116: {
        !           117: unsigned int   c_next:13,      
        !           118:                c_prev:13,      
        !           119:                c_lock:1,       
        !           120:                c_want:1,       
        !           121:                c_page:16,      
        !           122:                c_hlink:13,     
        !           123:                c_intrans:1,    
        !           124:                c_free:1,       
        !           125:                c_gone:1,       
        !           126:                c_type:2,       
        !           127:                c_blkno:20,     
        !           128:                c_ndx:10,       
        !           129:                c_mdev:6;       
        !           130: };
        !           131: struct cmap *cmap;
        !           132: struct cmap *ecmap;
        !           133: int    ncmap;
        !           134: struct cmap *mfind();
        !           135: int    firstfree, maxfree;
        !           136: int    ecmx;                   
        !           137: short  cmhash[512              ];
        !           138: struct direct
        !           139: {
        !           140:        ino_t   d_ino;
        !           141:        char    d_name[14               ];
        !           142: };
        !           143: struct pcb
        !           144: {
        !           145:        int     pcb_ksp;        
        !           146:        int     pcb_esp;        
        !           147:        int     pcb_ssp;        
        !           148:        int     pcb_usp;        
        !           149:        int     pcb_r0; 
        !           150:        int     pcb_r1; 
        !           151:        int     pcb_r2; 
        !           152:        int     pcb_r3; 
        !           153:        int     pcb_r4; 
        !           154:        int     pcb_r5; 
        !           155:        int     pcb_r6; 
        !           156:        int     pcb_r7; 
        !           157:        int     pcb_r8; 
        !           158:        int     pcb_r9; 
        !           159:        int     pcb_r10; 
        !           160:        int     pcb_r11; 
        !           161:        int     pcb_r12; 
        !           162:        int     pcb_r13; 
        !           163:        int     pcb_pc;         
        !           164:        int     pcb_psl;        
        !           165:        struct  pte *pcb_p0br;  
        !           166:        int     pcb_p0lr;       
        !           167:        struct  pte *pcb_p1br;  
        !           168:        int     pcb_p1lr;       
        !           169:        int     pcb_szpt;       
        !           170:        int     pcb_cmap2;
        !           171:        int     *pcb_sswap;
        !           172:        int     pcb_sigc[3];
        !           173: };
        !           174: struct dmap
        !           175: {
        !           176:        swblk_t dm_size;        
        !           177:        swblk_t dm_alloc;       
        !           178:        swblk_t dm_map[         32      ];      
        !           179: };
        !           180: struct dmap zdmap;
        !           181: struct dblock
        !           182: {
        !           183:        swblk_t db_base;        
        !           184:        swblk_t db_size;        
        !           185: };
        !           186: struct vtimes {
        !           187:        int     vm_utime;               
        !           188:        int     vm_stime;               
        !           189:        
        !           190:        unsigned vm_idsrss;             
        !           191:        unsigned vm_ixrss;              
        !           192:        int     vm_maxrss;              
        !           193:        int     vm_majflt;              
        !           194:        int     vm_minflt;              
        !           195:        int     vm_nswap;               
        !           196:        int     vm_inblk;               
        !           197:        int     vm_oublk;               
        !           198: };
        !           199: struct vtimes zvms;            
        !           200:  
        !           201:  
        !           202: struct user
        !           203: {
        !           204:        struct  pcb u_pcb;
        !           205:        int     u_arg[5];               
        !           206:        label_t u_qsav;                 
        !           207:        char    u_segflg;               
        !           208:        char    u_error;                
        !           209:        short   u_uid;                  
        !           210:        short   u_gid;                  
        !           211:        short   u_ruid;                 
        !           212:        short   u_rgid;                 
        !           213:        struct  proc *u_procp;          
        !           214:        int     *u_ap;                  
        !           215:        union {                         
        !           216:                struct  {
        !           217:                        int     R_val1;
        !           218:                        int     R_val2;
        !           219:                } u_rv;
        !           220:                off_t   r_off;
        !           221:                time_t  r_time;
        !           222:        } u_r;
        !           223:        caddr_t u_base;                 
        !           224:        unsigned int u_count;           
        !           225:        off_t   u_offset;               
        !           226:        struct  inode *u_cdir;          
        !           227:        struct  inode *u_rdir;          
        !           228:        char    u_dbuf[14               ];              
        !           229:        caddr_t u_dirp;                 
        !           230:        struct  direct u_dent;          
        !           231:        struct  inode *u_pdir;          
        !           232:        struct  file *u_ofile[20                ];      
        !           233:        char    u_pofile[20             ];      
        !           234:        label_t u_ssav;                 
        !           235:        int     (*u_signal[32])();      
        !           236:        int     u_code;                 
        !           237:        int     *u_ar0;                 
        !           238:        struct uprof {                  
        !           239:                short   *pr_base;       
        !           240:                unsigned pr_size;       
        !           241:                unsigned pr_off;        
        !           242:                unsigned pr_scale;      
        !           243:        } u_prof;
        !           244:        char    u_eosys;                
        !           245:        char    u_sep;                  
        !           246:        dev_t   u_ttydev;               
        !           247:        ino_t   u_ttyino;
        !           248:        union {
        !           249:           struct {                     
        !           250:                int     Ux_mag;         
        !           251:                unsigned Ux_tsize;      
        !           252:                unsigned Ux_dsize;      
        !           253:                unsigned Ux_bsize;      
        !           254:                unsigned Ux_ssize;      
        !           255:                unsigned Ux_entloc;     
        !           256:                unsigned Ux_unused;
        !           257:                unsigned Ux_relflg;
        !           258:           } Ux_A;
        !           259:           char ux_shell[32];   
        !           260:        } u_exdata;
        !           261:        char    u_comm[14               ];
        !           262:        time_t  u_start;
        !           263:        char    u_acflag;
        !           264:        short   u_fpflag;               
        !           265:        short   u_cmask;                
        !           266:        size_t  u_tsize;                
        !           267:        size_t  u_dsize;                
        !           268:        size_t  u_ssize;                
        !           269:        struct  vtimes u_vm;            
        !           270:        struct  vtimes u_cvm;           
        !           271:        struct  dmap u_dmap;            
        !           272:        struct  dmap u_smap;            
        !           273:        struct  dmap u_cdmap, u_csmap;  
        !           274:        time_t  u_outime;               
        !           275:        size_t  u_odsize, u_ossize;     
        !           276:        size_t  u_vrpages[20            ];      
        !           277:        int     u_limit[8];             
        !           278:        int     u_stack[1];
        !           279:                                        
        !           280: };
        !           281: extern struct user u;
        !           282: extern struct user swaputl;
        !           283: extern struct user forkutl;
        !           284: extern struct user xswaputl;
        !           285: extern struct user xswap2utl;
        !           286: extern struct user pushutl;
        !           287: extern struct user vfutl;
        !           288: extern struct user prusrutl;
        !           289: struct proc
        !           290: {
        !           291:        struct  proc *p_link;   
        !           292:        struct  proc *p_rlink;  
        !           293:        struct  pte *p_addr;    
        !           294:        char    p_usrpri;       
        !           295:        char    p_pri;          
        !           296:        char    p_cpu;          
        !           297:        char    p_stat;
        !           298:        char    p_time;         
        !           299:        char    p_nice;         
        !           300:        char    p_slptime;      
        !           301:        char    p_cursig;
        !           302:        long    p_sig;          
        !           303:        long    p_siga0;        
        !           304:        long    p_siga1;        
        !           305:        int     p_flag;
        !           306:        short   p_uid;          
        !           307:        short   p_pgrp;         
        !           308:        short   p_pid;          
        !           309:        short   p_ppid;         
        !           310:        short   p_poip;         
        !           311:        short   p_szpt;         
        !           312:        size_t  p_tsize;        
        !           313:        size_t  p_dsize;        
        !           314:        size_t  p_ssize;        
        !           315:        size_t  p_rssize;       
        !           316:        size_t  p_maxrss;       
        !           317:        size_t  p_swrss;        
        !           318:        swblk_t p_swaddr;       
        !           319:        caddr_t p_wchan;        
        !           320:        struct  text *p_textp;  
        !           321:        u_short p_clktim;       
        !           322:        u_short p_tsleep;       
        !           323:        struct  pte *p_p0br;    
        !           324:        struct  proc *p_xlink;  
        !           325:        short   p_cpticks;      
        !           326:        float   p_pctcpu;       
        !           327:        short   p_ndx;          
        !           328:        short   p_idhash;       
        !           329:        struct  proc *p_pptr;   
        !           330:        struct  inode *p_trace; 
        !           331: };
        !           332: short  pidhash[        63];
        !           333: struct proc *pfind();
        !           334: struct proc *proc, *procNPROC; 
        !           335: int    nproc;
        !           336: struct prochd {
        !           337:        struct  proc *ph_link;  
        !           338:        struct  proc *ph_rlink;
        !           339: } qs[32                ];
        !           340: int    whichqs;                
        !           341: struct xproc
        !           342: {
        !           343:        struct  proc *xp_link;
        !           344:        struct  proc *xp_rlink;
        !           345:        struct  pte *xp_addr;
        !           346:        char    xp_usrpri;
        !           347:        char    xp_pri;         
        !           348:        char    xp_cpu;         
        !           349:        char    xp_stat;
        !           350:        char    xp_time;        
        !           351:        char    xp_nice;        
        !           352:        char    xp_slptime;
        !           353:        char    p_cursig;
        !           354:        int     xp_sig;         
        !           355:        int     xp_siga0;
        !           356:        int     xp_siga1;
        !           357:        int     xp_flag;
        !           358:        short   xp_uid;         
        !           359:        short   xp_pgrp;        
        !           360:        short   xp_pid;         
        !           361:        short   xp_ppid;        
        !           362:        short   xp_xstat;       
        !           363:        struct  vtimes xp_vm;
        !           364: };
        !           365: struct text
        !           366: {
        !           367:        swblk_t x_daddr[12              ];      
        !           368:        swblk_t x_ptdaddr;      
        !           369:        size_t  x_size;         
        !           370:        struct proc *x_caddr;   
        !           371:        struct inode *x_iptr;   
        !           372:        short   x_rssize;
        !           373:        short   x_swrss;
        !           374:        char    x_count;        
        !           375:        char    x_ccount;       
        !           376:        char    x_flag;         
        !           377:        char    x_slptime;
        !           378:        short   x_poip;         
        !           379: };
        !           380: struct text *text, *textNTEXT;
        !           381: int    ntext;
        !           382:                                        
        !           383:                                        
        !           384: int    klseql;
        !           385: int    klsdist;
        !           386: int    klin;
        !           387: int    kltxt;
        !           388: int    klout;
        !           389: struct vmmeter
        !           390: {
        !           391:        unsigned v_swtch;       
        !           392:        unsigned v_trap;        
        !           393:        unsigned v_syscall;     
        !           394:        unsigned v_intr;        
        !           395:        unsigned v_pdma;        
        !           396:        unsigned v_pswpin;      
        !           397:        unsigned v_pswpout;     
        !           398:        unsigned v_pgin;        
        !           399:        unsigned v_pgout;       
        !           400:        unsigned v_pgpgin;      
        !           401:        unsigned v_pgpgout;     
        !           402:        unsigned v_intrans;     
        !           403:        unsigned v_pgrec;       
        !           404:        unsigned v_xsfrec;      
        !           405:        unsigned v_xifrec;      
        !           406:        unsigned v_exfod;       
        !           407:        unsigned v_zfod;        
        !           408:        unsigned v_vrfod;       
        !           409:        unsigned v_nexfod;      
        !           410:        unsigned v_nzfod;       
        !           411:        unsigned v_nvrfod;      
        !           412:        unsigned v_pgfrec;      
        !           413:        unsigned v_faults;      
        !           414:        unsigned v_scan;        
        !           415:        unsigned v_rev;         
        !           416:        unsigned v_seqfree;     
        !           417:        unsigned v_dfree;       
        !           418:        unsigned v_swpin;       
        !           419:        unsigned v_swpout;      
        !           420: };
        !           421: struct vmmeter cnt, rate, sum;
        !           422: struct vmtotal
        !           423: {
        !           424:        short   t_rq;           
        !           425:        short   t_dw;           
        !           426:        short   t_pw;           
        !           427:        short   t_sl;           
        !           428:        short   t_sw;           
        !           429:        int     t_vm;           
        !           430:        int     t_avm;          
        !           431:        short   t_rm;           
        !           432:        short   t_arm;          
        !           433:        int     t_vmtxt;        
        !           434:        int     t_avmtxt;       
        !           435:        short   t_rmtxt;        
        !           436:        short   t_armtxt;       
        !           437:        short   t_free;         
        !           438: };
        !           439: struct vmtotal total;
        !           440: int    freemem;                
        !           441: int    avefree;                
        !           442: int    avefree30;              
        !           443: int    deficit;                
        !           444: int    nscan;                  
        !           445: int    multprog;               
        !           446: int    desscan;                
        !           447: int    maxpgio;                
        !           448: int    maxslp;                 
        !           449: int    lotsfree;               
        !           450: int    minfree;                
        !           451: int    desfree;                
        !           452: int    saferss;                
        !           453: struct forkstat
        !           454: {
        !           455:        int     cntfork;
        !           456:        int     cntvfork;
        !           457:        int     sizfork;
        !           458:        int     sizvfork;
        !           459: };
        !           460: struct forkstat forkstat;
        !           461: struct swptstat
        !           462: {
        !           463:        int     pteasy;         
        !           464:        int     ptexpand;       
        !           465:        int     ptshrink;       
        !           466:        int     ptpack;         
        !           467: };
        !           468: struct swptstat swptstat;
        !           469: struct file
        !           470: {
        !           471:        short   f_flag;
        !           472:        short   f_count;                
        !           473:        struct inode *f_inode;          
        !           474:        off_t   f_offset;               
        !           475: };
        !           476: struct file *file, *fileNFILE; 
        !           477: int    nfile;
        !           478: struct file *getf();
        !           479: struct file *falloc();
        !           480: struct inode
        !           481: {
        !           482:        short   i_flag;
        !           483:        u_char  i_count;        
        !           484:        char    i_fstyp;        
        !           485:        dev_t   i_dev;          
        !           486:        long    i_number;       
        !           487:        unsigned short i_mode;
        !           488:        short   i_nlink;        
        !           489:        short   i_uid;          
        !           490:        short   i_gid;          
        !           491:        off_t   i_size;         
        !           492:        struct  stdata *i_sptr; 
        !           493:        union {
        !           494:                struct {
        !           495:                        daddr_t I_addr[13];     
        !           496:                        daddr_t I_lastr;        
        !           497:                } i_f;
        !           498:                struct {
        !           499:                        daddr_t I_rdev;         
        !           500:                        long    I_key;          
        !           501:                } i_d;
        !           502:                struct {
        !           503:                        long I_tag;
        !           504:                        struct inode *I_cip;    
        !           505:                } i_a;          
        !           506:                struct {
        !           507:                        struct proc *I_proc;    
        !           508:                        int         I_sigmask;  
        !           509:                } i_p;
        !           510:        } i_un;
        !           511:        short   i_hlink;        
        !           512: };
        !           513: struct inode *inode, *inodeNINODE;
        !           514: int    ninode;
        !           515: struct inode *rootdir;         
        !           516: struct inode *ialloc();
        !           517: struct inode *ifind();
        !           518: struct inode *iget();
        !           519: struct inode *owner();
        !           520: struct inode *maknode();
        !           521: struct inode *namei();
        !           522: struct argnamei {      
        !           523:        short flag;     
        !           524:        ino_t ino;      
        !           525:        dev_t idev;
        !           526:        short mode;     
        !           527: };
        !           528: struct nx {    
        !           529:        struct inode *dp;
        !           530:        char *cp;
        !           531:        struct buf *nbp;
        !           532:        int nlink;
        !           533: };
        !           534: struct bufhd
        !           535: {
        !           536:        long    b_flags;                
        !           537:        struct  buf *b_forw, *b_back;   
        !           538: };
        !           539: struct buf
        !           540: {
        !           541:        long    b_flags;                
        !           542:        struct  buf *b_forw, *b_back;   
        !           543:        struct  buf *av_forw, *av_back; 
        !           544:        long    b_bcount;               
        !           545:        short   b_error;                
        !           546:        dev_t   b_dev;                  
        !           547:        union {
        !           548:            caddr_t b_addr;             
        !           549:            int *b_words;               
        !           550:            struct filsys *b_filsys;    
        !           551:            struct dinode *b_dino;      
        !           552:            daddr_t *b_daddr;           
        !           553:        } b_un;
        !           554:        daddr_t b_blkno;                
        !           555:        long    b_resid;                
        !           556:        struct  proc *b_proc;           
        !           557: };
        !           558: struct buf *buf;               
        !           559: char   *buffers;
        !           560: int    nbuf;
        !           561: struct buf *swbuf;             
        !           562: int    nswbuf;
        !           563: short  *swsize;
        !           564: int    *swpf;
        !           565: struct buf bfreelist[  3               ];      
        !           566: struct buf bswlist;            
        !           567: struct buf *bclnlist;          
        !           568: struct buf *alloc();
        !           569: struct buf *baddr();
        !           570: struct buf *getblk();
        !           571: struct buf *geteblk();
        !           572: struct buf *bread();
        !           573: struct buf *breada();
        !           574: unsigned minphys();
        !           575: struct mount   
        !           576: {
        !           577:        dev_t   m_dev;          
        !           578:        struct  buf *m_bufp;    
        !           579:        struct  inode *m_inodp; 
        !           580:        struct  inode *m_idev;  
        !           581:        int     m_fstyp;        
        !           582: };
        !           583: struct mount mount[62          ];
        !           584:                                        
        !           585: struct map {
        !           586:        struct  mapent *m_limit;        
        !           587:        char    *m_name;                
        !           588: };
        !           589: struct mapent
        !           590: {
        !           591:        int     m_size;         
        !           592:        int     m_addr;         
        !           593: };
        !           594: struct map *swapmap;
        !           595: int    nswapmap;
        !           596: struct map *argmap;
        !           597: struct map *kernelmap;
        !           598: vmemall(pte, size, p, type)
        !           599:        register struct pte *pte;
        !           600:        int size;
        !           601:        struct proc *p;
        !           602: {
        !           603:        register int m;
        !           604:        if (size <= 0 || size > maxmem)
        !           605:                panic("vmemall size");
        !           606:        while (size > 0) {
        !           607:                if (freemem < desfree)
        !           608:                        wakeup((caddr_t)&proc[2]);      
        !           609:                while (freemem == 0)
        !           610:                        sleep((caddr_t)&freemem, 0+2);
        !           611:                m = imin(size, freemem);
        !           612:                (void) memall(pte, m, p, type);
        !           613:                size -= m;
        !           614:                pte += m;
        !           615:        }
        !           616:        if (freemem < desfree)
        !           617:                wakeup((caddr_t)&proc[2]);              
        !           618:        
        !           619:        return (1);
        !           620: }
        !           621: vmemfree(pte, count)
        !           622:        register struct pte *pte;
        !           623:        register int count;
        !           624: {
        !           625:        register struct cmap *c;
        !           626:        register struct pte *spte;
        !           627:        register int j;
        !           628:        int size, pcnt, fileno;
        !           629:        if (count % 2)
        !           630:                panic("vmemfree");
        !           631:        for (size = 0, pcnt = 0; count > 0; pte += 2, count -= 2) {
        !           632:                if (pte->pg_fod == 0 && pte->pg_pfnum) {
        !           633:                        c = &cmap[      ((((pte->pg_pfnum)-firstfree) / 2) + 1)];
        !           634:                        pcnt += 2;
        !           635:                        if (c->c_lock && c->c_type !=   0               ) {
        !           636:                                for (j = 0; j < 2; j++)
        !           637:                                        *(int *)(pte+j) &= (    0x78000000|0x00800000);
        !           638:                                c->c_gone = 1;
        !           639:                                goto free;
        !           640:                        }
        !           641:                        if (c->c_free) {
        !           642:                                pcnt -= 2;
        !           643:                                for (j = 0; j < 2; j++)
        !           644:                                        *(int *)(pte+j) &= (    0x78000000|0x00800000);
        !           645:                                if (c->c_type ==        1               )
        !           646:                                        distpte(&text[c->c_ndx], (int)c->c_page, pte);
        !           647:                                c->c_gone = 1;
        !           648:                                goto free;
        !           649:                        }
        !           650:                        if (size == 0)
        !           651:                                spte = pte;
        !           652:                        size += 2;
        !           653:                        continue;
        !           654:                }
        !           655:                if (pte->pg_fod) {
        !           656:                        fileno = ((struct fpte *)pte)->pg_fileno;
        !           657:                        if (fileno < 20         )
        !           658:                                if ((u.u_vrpages[fileno] -= 2) <= 0)
        !           659:                                        if (u.u_vrpages[fileno] < 0)
        !           660:                                                panic("vmemfree vrpages");
        !           661:                        for (j = 0; j < 2; j++)
        !           662:                                *(int *)(pte+j) &= (    0x78000000|0x00800000);
        !           663:                }
        !           664: free:
        !           665:                if (size) {
        !           666:                        memfree(spte, size, 1);
        !           667:                        size = 0;
        !           668:                }
        !           669:        }
        !           670:        if (size)
        !           671:                memfree(spte, size, 1);
        !           672:        return (pcnt);
        !           673: }
        !           674: munlink(pf)
        !           675:        unsigned pf;
        !           676: {
        !           677:        register int next, prev;
        !           678:        next = cmap[    ((((pf)-firstfree) / 2) + 1)].c_next;
        !           679:        prev = cmap[    ((((pf)-firstfree) / 2) + 1)].c_prev;
        !           680:        cmap[prev].c_next = next;
        !           681:        cmap[next].c_prev = prev;
        !           682:        cmap[   ((((pf)-firstfree) / 2) + 1)].c_free = 0;
        !           683:        if (freemem < minfree)
        !           684:                wakeup((caddr_t)&proc[2]);      
        !           685:        freemem -= 2;
        !           686: }
        !           687: memall(pte, size, p, type)
        !           688:        register struct pte *pte;
        !           689:        int size;
        !           690:        struct proc *p;
        !           691: {
        !           692:        register struct cmap *c;
        !           693:        register struct pte *rpte;
        !           694:        register struct proc *rp;
        !           695:        int i, j, next, curpos;
        !           696:        unsigned pf;
        !           697:        struct cmap *c1, *c2;
        !           698:        if (size % 2)
        !           699:                panic("memall");
        !           700:        if (size > freemem)
        !           701:                return (0);
        !           702:        ;
        !           703:        for (i = size; i > 0; i -= 2) {
        !           704:                curpos = cmap[0].c_next;
        !           705:                c = &cmap[curpos];
        !           706:                if (c->c_free == 0)
        !           707:                        panic("dup mem alloc");
        !           708:                if (    ((((curpos)-1) * 2) + firstfree) > maxfree)
        !           709:                        panic("bad mem alloc");
        !           710:                if (c->c_gone == 0 && c->c_type !=      0               ) {
        !           711:                        if (c->c_type ==        1               )
        !           712:                                rp = text[c->c_ndx].x_caddr;
        !           713:                        else
        !           714:                                rp = &proc[c->c_ndx];
        !           715:                        while (rp->p_flag & 0x00004000  )
        !           716:                                rp = rp->p_xlink;
        !           717:                        switch (c->c_type) {
        !           718:                        case    1               :
        !           719:                                rpte =          ((rp)->p_p0br + ( c->c_page));
        !           720:                                break;
        !           721:                        case    2               :
        !           722:                                rpte =          ((rp)->p_p0br + (rp)->p_tsize + ( c->c_page));
        !           723:                                break;
        !           724:                        case    3               :
        !           725:                                rpte =          (((rp)->p_p0br + (rp)->p_szpt*  (       512/(sizeof (struct pte))) - 8           - 1) - ( c->c_page));
        !           726:                                break;
        !           727:                        }
        !           728:                                (rpte)[1]. pg_pfnum = (rpte)[0]. pg_pfnum = 0;
        !           729:                        if (c->c_type ==        1               )
        !           730:                                distpte(&text[c->c_ndx], (int)c->c_page, rpte);
        !           731:                }
        !           732:                switch (type) {
        !           733:                case    0               :
        !           734:                        c->c_ndx = p->p_ndx;
        !           735:                        break;
        !           736:                case    1               :
        !           737:                        c->c_page =     ((int)( ptetov(p, pte)));
        !           738:                        c->c_ndx = p->p_textp - &text[0];
        !           739:                        break;
        !           740:                case    2               :
        !           741:                        c->c_page =     ((int)(( ptetov(p, pte)) - (p)->p_tsize));
        !           742:                        c->c_ndx = p->p_ndx;
        !           743:                        break;
        !           744:                case    3               :
        !           745:                        c->c_page =     ((int)(         (((unsigned)((0x80000000-8              *       512))) >>       9               ) - 1 - ( ptetov(p, pte))));
        !           746:                        c->c_ndx = p->p_ndx;
        !           747:                        break;
        !           748:                }
        !           749:                if (c->c_blkno) {
        !           750:                        
        !           751:                        j =     ((c->c_blkno)&(512              -1));
        !           752:                        c1 = &cmap[cmhash[j]];
        !           753:                        if (c1 == c)
        !           754:                                cmhash[j] = c1->c_hlink;
        !           755:                        else {
        !           756:                                for (;;) {
        !           757:                                        if (c1 == ecmap)
        !           758:                                                panic("memall ecmap");
        !           759:                                        c2 = c1;
        !           760:                                        c1 = &cmap[c2->c_hlink];
        !           761:                                        if (c1 == c)
        !           762:                                                break;
        !           763:                                }
        !           764:                                c2->c_hlink = c1->c_hlink;
        !           765:                        }
        !           766:                        if (mfind(c->c_mdev == 15                ?
        !           767:                              swapdev : mount[c->c_mdev].m_dev,
        !           768:                              (daddr_t)c->c_blkno))
        !           769:                                panic("memall mfind");
        !           770:                        c1->c_mdev = 0;
        !           771:                        c1->c_blkno = 0;
        !           772:                        c1->c_hlink = 0;
        !           773:                }
        !           774:                pf =    ((((curpos)-1) * 2) + firstfree);
        !           775:                for (j = 0; j < 2; j++)
        !           776:                        *(int *)pte++ = pf++;
        !           777:                c->c_free = 0;
        !           778:                c->c_gone = 0;
        !           779:                if (c->c_intrans || c->c_want)
        !           780:                        panic("memall intrans|want");
        !           781:                c->c_lock = 1;
        !           782:                c->c_type = type;
        !           783:                freemem -= 2;
        !           784:                next = c->c_next;
        !           785:                cmap[0].c_next = next;
        !           786:                cmap[next].c_prev = 0;
        !           787:        }
        !           788:        return (size);
        !           789: }
        !           790: memfree(pte, size, detach)
        !           791:        register struct pte *pte;
        !           792:        register int size;
        !           793: {
        !           794:        register int i, j, prev, next;
        !           795:        register struct cmap *c;
        !           796:        
        !           797:        if (size % 2)
        !           798:                panic("memfree");
        !           799:        if (freemem < 2 * (32/2))
        !           800:                wakeup((caddr_t)&freemem);
        !           801:        while (size > 0) {
        !           802:                size -= 2;
        !           803:                i = pte->pg_pfnum;
        !           804:                if (i < firstfree || i > maxfree)
        !           805:                        panic("bad mem free");
        !           806:                i =     ((((i)-firstfree) / 2) + 1);
        !           807:                c = &cmap[i];
        !           808:                if (c->c_free)
        !           809:                        panic("dup mem free");
        !           810:                if (detach && c->c_type !=      0               ) {
        !           811:                        for (j = 0; j < 2; j++)
        !           812:                                *(int *)(pte+j) &= (    0x78000000|0x00800000);
        !           813:                        c->c_gone = 1;
        !           814:                }
        !           815:                if (detach && c->c_blkno == 0) {
        !           816:                        next = cmap[0].c_next;
        !           817:                        cmap[next].c_prev = i;
        !           818:                        c->c_prev = 0;
        !           819:                        c->c_next = next;
        !           820:                        cmap[0].c_next = i;
        !           821:                } else {
        !           822:                        prev = cmap[0].c_prev;
        !           823:                        cmap[prev].c_next = i;
        !           824:                        c->c_next = 0;
        !           825:                        c->c_prev = prev;
        !           826:                        cmap[0].c_prev = i;
        !           827:                }
        !           828:                c->c_free = 1;
        !           829:                freemem += 2;
        !           830:                pte += 2;
        !           831:        }
        !           832: }
        !           833: caddr_t
        !           834: wmemall(pmemall, n)
        !           835:        int (*pmemall)(), n;
        !           836: {
        !           837:        int npg;
        !           838:        caddr_t va;
        !           839:        register int a;
        !           840:        npg =   ((((unsigned)(n)+511)>>9));
        !           841:        a = rmalloc(kernelmap, npg);
        !           842:        if (a == 0)
        !           843:                return (0);
        !           844:        if ((*pmemall)(&Usrptmap[a], npg, &proc[0],     0               ) == 0) {
        !           845:                rmfree(kernelmap, npg, a);
        !           846:                return (0);
        !           847:        }
        !           848:        va = (caddr_t)  (usrpt + (a) *  (       512/(sizeof (struct pte))));
        !           849:        vmaccess(&Usrptmap[a], va, npg);
        !           850:        return (va);
        !           851: }
        !           852: wmemfree(va, n)
        !           853:        caddr_t va;
        !           854:        int n;
        !           855: {
        !           856:        register int a;
        !           857:        int npg;
        !           858:        a =     ((((struct pte *) va) - usrpt) /        (       512/(sizeof (struct pte))));
        !           859:        npg =   ((((unsigned)(n)+511)>>9));
        !           860:        (void) memfree(&Usrptmap[a], npg, 0);
        !           861:        rmfree(kernelmap, npg, a);
        !           862: }
        !           863: mhash(c, dev, bn)
        !           864:        register struct cmap *c;
        !           865:        dev_t dev;
        !           866:        daddr_t bn;
        !           867: {
        !           868:        register int i =        ((bn)&(512              -1));
        !           869:        c->c_hlink = cmhash[i];
        !           870:        cmhash[i] = c - cmap;
        !           871:        c->c_blkno = bn;
        !           872:        i = getfsx(dev);
        !           873:        if (i == -1)
        !           874:                panic("mhash");
        !           875:        c->c_mdev = i;
        !           876: }
        !           877: munhash(dev, bn)
        !           878:        dev_t dev;
        !           879:        daddr_t bn;
        !           880: {
        !           881:        register int i =        ((bn)&(512              -1));
        !           882:        register struct cmap *c1, *c2;
        !           883:        c1 = &cmap[cmhash[i]];
        !           884:        if (c1 == ecmap)
        !           885:                panic("munhash");
        !           886:        if (c1->c_blkno == bn && getfsx(dev) == c1->c_mdev)
        !           887:                cmhash[i] = c1->c_hlink;
        !           888:        else {
        !           889:                for (;;) {
        !           890:                        c2 = c1;
        !           891:                        c1 = &cmap[c2->c_hlink];
        !           892:                        if (c1 == ecmap)
        !           893:                                panic("munhash");
        !           894:                        if (c1->c_blkno == bn && getfsx(dev) == c1->c_mdev)
        !           895:                                break;
        !           896:                }
        !           897:                c2->c_hlink = c1->c_hlink;
        !           898:        }
        !           899:        if (mfind(dev, bn))
        !           900:                panic("munhash mfind");
        !           901:        c1->c_mdev = 0;
        !           902:        c1->c_blkno = 0;
        !           903:        c1->c_hlink = 0;
        !           904: }
        !           905: struct cmap *
        !           906: mfind(dev, bn)
        !           907:        dev_t dev;
        !           908:        daddr_t bn;
        !           909: {
        !           910:        register struct cmap *c1 = &cmap[cmhash[        ((bn)&(512              -1))]];
        !           911:        while (c1 != ecmap) {
        !           912:                if (c1->c_blkno == bn && c1->c_mdev == getfsx(dev))
        !           913:                        return (c1);
        !           914:                c1 = &cmap[c1->c_hlink];
        !           915:        }
        !           916:        return ((struct cmap *)0);
        !           917: }
        !           918: mpurge(mdev)
        !           919:        int mdev;
        !           920: {
        !           921:        register struct cmap *c1, *c2;
        !           922:        register int i;
        !           923:        for (i = 0; i < 512             ; i++) {
        !           924: more:
        !           925:                c1 = &cmap[cmhash[i]];
        !           926:                if (c1 == ecmap)
        !           927:                        continue;
        !           928:                if (c1->c_mdev == mdev)
        !           929:                        cmhash[i] = c1->c_hlink;
        !           930:                else {
        !           931:                        for (;;) {
        !           932:                                c2 = c1;
        !           933:                                c1 = &cmap[c1->c_hlink];
        !           934:                                if (c1 == ecmap)
        !           935:                                        goto cont;
        !           936:                                if (c1->c_mdev == mdev)
        !           937:                                        break;
        !           938:                        }
        !           939:                        c2->c_hlink = c1->c_hlink;
        !           940:                }
        !           941:                c1->c_mdev = 0;
        !           942:                c1->c_blkno = 0;
        !           943:                c1->c_hlink = 0;
        !           944:                goto more;
        !           945: cont:
        !           946:                ;
        !           947:        }
        !           948: }
        !           949: meminit(first, last)
        !           950:        int first, last;
        !           951: {
        !           952:        register int i;
        !           953:        register struct cmap *c;
        !           954:        firstfree =     (((first) + (2-1)) &~ (2-1));
        !           955:        maxfree =       (((last - (2 - 1)) + (2-1)) &~ (2-1));
        !           956:        freemem = maxfree - firstfree;
        !           957:        ecmx = ecmap - cmap;
        !           958:        if (ecmx < freemem / 2)
        !           959:                freemem = ecmx * 2;
        !           960:        for (i = 1; i <= freemem / 2; i++) {
        !           961:                cmap[i-1].c_next = i;
        !           962:                c = &cmap[i];
        !           963:                c->c_prev = i-1;
        !           964:                c->c_free = 1;
        !           965:                c->c_gone = 1;
        !           966:                c->c_type =     0               ;
        !           967:                c->c_mdev = 0;
        !           968:                c->c_blkno = 0;
        !           969:        }
        !           970:        cmap[freemem / 2].c_next = 0;
        !           971:        for (i = 0; i < 512             ; i++)
        !           972:                cmhash[i] = ecmx;
        !           973:        cmap[0].c_prev = freemem / 2;
        !           974:        cmap[0].c_type =        0               ;
        !           975:        avefree = freemem;
        !           976:        hand = 0;
        !           977: }
        !           978: mwait(pf)
        !           979:        unsigned pf;
        !           980: {
        !           981:        mlock(pf);
        !           982:        munlock(pf);
        !           983: }
        !           984: mlock(pf)
        !           985:        unsigned pf;
        !           986: {
        !           987:        register struct cmap *c = &cmap[        ((((pf)-firstfree) / 2) + 1)];
        !           988:        while (c->c_lock) {
        !           989:                c->c_want = 1;
        !           990:                sleep((caddr_t)c, 0+1);
        !           991:        }
        !           992:        c->c_lock = 1;
        !           993: }
        !           994: munlock(pf)
        !           995:        unsigned pf;
        !           996: {
        !           997:        register struct cmap *c = &cmap[        ((((pf)-firstfree) / 2) + 1)];
        !           998:        if (c->c_lock == 0)
        !           999:                panic("dup page unlock");
        !          1000:        if (c->c_want)
        !          1001:                wakeup((caddr_t)c);
        !          1002:        c->c_lock = 0;
        !          1003:        c->c_want = 0;
        !          1004: }
        !          1005: vslock(base, count)
        !          1006:        caddr_t base;
        !          1007: {
        !          1008:        register unsigned v;
        !          1009:        register int npf;
        !          1010:        register struct pte *pte;
        !          1011:        u.u_procp->p_flag |= 0x00000200 ;
        !          1012:        v =             (((unsigned)(base)) >>  9               );
        !          1013:        pte = vtopte(u.u_procp, v);
        !          1014:        npf =   ((((unsigned)(count + ((int)base &      (2*     512-1)  ))+511)>>9));
        !          1015:        while (npf > 0) {
        !          1016:                if (pte->pg_v) 
        !          1017:                        mlock(pte->pg_pfnum);
        !          1018:                else
        !          1019:                        if (fubyte((caddr_t)    ((v)<<9)) < 0)
        !          1020:                                panic("vslock");
        !          1021:                pte += 2;
        !          1022:                v += 2;
        !          1023:                npf -= 2;
        !          1024:        }
        !          1025:        u.u_procp->p_flag &= ~0x00000200        ;
        !          1026: }
        !          1027: vsunlock(base, count, rw)
        !          1028:        caddr_t base;
        !          1029: {
        !          1030:        register struct pte *pte;
        !          1031:        register int npf;
        !          1032:        pte = vtopte(u.u_procp,                 (((unsigned)(base)) >>  9               ));
        !          1033:        npf =   ((((unsigned)(count + ((int)base &      (2*     512-1)  ))+511)>>9));
        !          1034:        while (npf > 0) {
        !          1035:                munlock(pte->pg_pfnum);
        !          1036:                if (rw ==       0x000001        )       
        !          1037:                        pte->pg_m = 1;
        !          1038:                pte += 2;
        !          1039:                npf -= 2;
        !          1040:        }
        !          1041: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.