Mercurial > hg > Members > kono > os9 > sbc09

comparison vdisk.c @ 49:947cbecdd8d5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
read and dir worked. exec failed
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Sat, 21 Jul 2018 19:25:53 +0900
parents ea1b17311bf3
children 1430678cd4fb
comparison
equal deleted inserted replaced
48:ea1b17311bf3 49:947cbecdd8d5
13 #include <sys/stat.h> 13 #include <sys/stat.h>
14 #include <sys/select.h> 14 #include <sys/select.h>
15 #include <dirent.h> 15 #include <dirent.h>
16 #include <string.h> 16 #include <string.h>
17 #include <time.h> 17 #include <time.h>
18 18 #include <arpa/inet.h>
19 19
20 20 static int vdiskdebug = 1; // 1 trace, 2 filename
21
22 extern char *prog ; // for disass
21 #ifdef USE_MMU 23 #ifdef USE_MMU
22 extern char *prog ; // for disass
23 extern Byte * mem0(Byte *iphymem, Word adr, Byte *immu) ; 24 extern Byte * mem0(Byte *iphymem, Word adr, Byte *immu) ;
24 // pmem physical address using current mmu
25 // smem physical address using system mmu 25 // smem physical address using system mmu
26 // umem physical address using caller's mmu 26 // umem physical address using caller's mmu
27 #define pmem(a) mem0(phymem,a,mmu)
28 #define smem(a) mem0(phymem,a,&mem[0x20+IOPAGE]) 27 #define smem(a) mem0(phymem,a,&mem[0x20+IOPAGE])
29 #define umem(a) (mem[0x42+IOPAGE]?mem0(phymem,a,&mem[0x28+IOPAGE]):mem0(phymem,a,&mem[0x20+IOPAGE])) 28 #define umem(a) (mem[0x42+IOPAGE]?mem0(phymem,a,&mem[0x28+IOPAGE]):mem0(phymem,a,&mem[0x20+IOPAGE]))
30 #else 29 #else
31 #define pmem(a) (&mem[a])
32 #define umem(a) (&mem[a]) 30 #define umem(a) (&mem[a])
33 #define smem(a) (&mem[a]) 31 #define smem(a) (&mem[a])
34 #endif 32 #endif
35 33
36 #define MAXPDV 256 34 #define MAXPDV 256
48 char dir; 46 char dir;
49 char *fd ; 47 char *fd ;
50 char *dirfp; 48 char *dirfp;
51 } PathDesc, *PathDescPtr; 49 } PathDesc, *PathDescPtr;
52 50
51 static void
52 vdisklog(Word u,PathDesc *pd, Word pdptr, int curdir,FILE *fp) ;
53
53 #define MAXVDRV 4 54 #define MAXVDRV 4
54 55
55 char *drvRoot[] = { ".",".",".","."}; 56 static char *drvRoot[] = { ".",".",".","."};
56 PathDesc pdv[MAXPDV]; 57 static PathDesc pdv[MAXPDV];
57 58
58 int setVdisk(int drv,char *name) { 59 /*
60 * us 0 system
61 * 1 caller
62 */
63 static inline Word
64 getword(Byte *adr) {
65 Word *padr = (Word*)adr;
66 return ntohs(*padr);
67 }
68
69 static inline void
70 setword(Byte *adr,Word value) {
71 Word *padr = (Word*)adr;
72 *padr = htons(value);
73 }
74
75 static int
76 setVdisk(int drv,char *name) {
59 if (drv<0 || drv>=MAXVDRV) return -1; 77 if (drv<0 || drv>=MAXVDRV) return -1;
60 drvRoot[drv] = name; 78 drvRoot[drv] = name;
61 return 0; 79 return 0;
62 } 80 }
63 81
64 void closepd(PathDesc *pd) { 82 static void
83 closepd(PathDesc *pd) {
65 if(pd->fp) fclose(pd->fp) ; 84 if(pd->fp) fclose(pd->fp) ;
66 pd->dir = 0; 85 pd->dir = 0;
67 pd->use = 0; 86 pd->use = 0;
68 pd->fp = 0; 87 pd->fp = 0;
69 pd->mode = 0; 88 pd->mode = 0;
70 free(pd->dirfp); pd->dirfp = 0; 89 free(pd->dirfp); pd->dirfp = 0;
71 free(pd->name); pd->name = 0; 90 free(pd->name); pd->name = 0;
72 } 91 }
73 92
93 /*
94 * keep track current directory ( most recently 256 entry )
95 * too easy approach
96 */
97 char *cdt[512];
98 static int cdtptr = 0;
99
100 Byte
101 setcd(char *name) {
102 int len;
103 for(int i=0;i<256;i++) {
104 if (cdt[i] && strcmp(name,cdt[i])==0) return i;
105 }
106 cdtptr &= 0xff;
107 if (cdt[cdtptr]) free(cdt[cdtptr]);
108 cdt[cdtptr] = (char*)malloc(len=strlen(name)+1);
109 strcpy(cdt[cdtptr],name);
110 return cdtptr++;
111 }
112
74 #define MAXPAHTLEN 256 113 #define MAXPAHTLEN 256
75 114
76 char *addCurdir(char *name, PathDesc *pd, PathDesc *curdir) { 115 static void
116 putOs9str(char *s) {
117 if (s==0) {
118 printf("(null)");
119 return;
120 }
121 while(*s && *s>=' ' && ((*s&0x80)==0)) {
122 putchar(*s); s++;
123 }
124 if (*s&0x80) putchar(*s&0x7f);
125 }
126
127 static char *
128 addCurdir(char *name, PathDesc *pd, int curdir) {
77 int ns =0 ; 129 int ns =0 ;
78 char *n = name; 130 char *n = name;
131 if(vdiskdebug&0x2) { printf("addcur \""); putOs9str(name); printf("\" cur \""); putOs9str( cdt[curdir]); printf("\"\n"); }
79 if (name[0]=='/') { 132 if (name[0]=='/') {
80 while(*name !='/' && *name!=0) name ++ ; // skip /d0 133 name++; while(*name !='/' && *name!=0) name ++ ; // skip /d0
81 while(name[ns]!=0) ns++; 134 while(name[ns]!=0) ns++;
82 } else if (curdir==0 || !curdir->name ) return 0; // no current directory 135 } else if (!cdt[curdir] ) return 0; // no current directory
136 else ns = strlen(name);
83 int ps = ns; 137 int ps = ns;
84 char *base ; 138 char *base ;
85 if (name[0]-='/') { 139 if (name[0]=='/') {
86 base = drvRoot[pd->drv]; ps += strlen(drvRoot[pd->drv])+1; 140 base = drvRoot[pd->drv]; ps += strlen(drvRoot[pd->drv])+1; name++;
87 } else if (name[0]==0) { 141 } else if (name[0]==0) {
88 base = drvRoot[pd->drv]; 142 base = drvRoot[pd->drv];
89 char *path = (char*)malloc(strlen(base)+1); // we'll free this, malloc it. 143 char *path = (char*)malloc(strlen(base)+1); // we'll free this, malloc it.
90 int i = 0; 144 int i = 0;
91 for(;base[i];i++) path[i] = base[i]; 145 for(;base[i];i++) path[i] = base[i];
92 path[i]=0; 146 path[i]=0;
93 return path; 147 return path;
94 } else { 148 } else {
95 name++; base = curdir->name; ps += strlen(curdir->name)+1; 149 base = cdt[curdir]; ps += strlen(cdt[curdir])+2;
96 } 150 }
97 char *path = (char*)malloc(ps+1); 151 char *path = (char*)malloc(ps);
98 int i = 0; 152 int i = 0;
99 for(;base[i];i++) path[i] = base[i]; 153 for(;base[i];i++) path[i] = base[i];
100 path[i++] = '/'; 154 path[i++] = '/';
101 for(int j=0;j<ns;j++,i++) path[i] = name[j]; 155 for(int j=0;j<ps;j++,i++) path[i] = name[j];
102 path[i++] = 0; 156 path[i++] = 0;
103 return path; 157 return path;
104 } 158 }
105 159
106 char * checkFileName(char *path, PathDesc *pd, PathDesc *curdir) { 160 static char *
161 checkFileName(char *path, PathDesc *pd, int curdir) {
107 char *p = path; 162 char *p = path;
108 char *name = path; 163 char *name = path;
109 int maxlen = MAXPAHTLEN; 164 int maxlen = MAXPAHTLEN;
165 if(vdiskdebug) { printf("checkf \""); putOs9str(name); printf("\"\n"); }
110 while(*p!=0 && (*p&0x80)==0 && (*p>0x1f) && maxlen-->0) p++; 166 while(*p!=0 && (*p&0x80)==0 && (*p>0x1f) && maxlen-->0) p++;
111 if (maxlen==MAXPAHTLEN) return 0; 167 if (maxlen==MAXPAHTLEN) return 0;
112 if (*p!=0) { 168 if (*p!=0) {
113 name = (char *)malloc(p-path+1); 169 name = (char *)malloc(p-path+1);
114 strncpy(name,path, MAXPAHTLEN-maxlen); 170 strncpy(name,path, MAXPAHTLEN-maxlen);
171 name[MAXPAHTLEN-maxlen-1] &= 0x7f;
115 name[MAXPAHTLEN-maxlen] = 0; 172 name[MAXPAHTLEN-maxlen] = 0;
116 } 173 }
117 char *name1 = addCurdir(name,pd,curdir); 174 char *name1 = addCurdir(name,pd,curdir);
118 if (name1!=name && name1!=path) free(name); 175 if (name1!=name && name1!=path) free(name);
119 if (name1==0) return 0; 176 if (name1==0) return 0;
120 pd->name = name1; 177 pd->name = name1;
178 if(vdiskdebug) {
179 printf(" remain = \"");
180 char *p1 = p;
181 while(*p1 && (*p1&0x80)==0 ) { if (*p1<0x20) printf("(0x%02x)",*p1); else putchar(*p1); p1++; }
182 if (*p1) { if ((*p1&0x7f)<0x20) printf("(0x%02x)",*p1); else putchar(*p1&0x7f); }
183 printf("\" checkname result \""); putOs9str(pd->name); printf("\"\n");
184 }
121 return p; 185 return p;
122 } 186 }
123 187
124 void os9setmode(char *os9mode,int mode) { 188 static void
189 os9setmode(char *os9mode,int mode) {
125 char m = 0; 190 char m = 0;
126 if (mode&S_IFDIR) m|=0x80; 191 if (mode&S_IFDIR) m|=0x80;
127 if (mode&S_IRUSR) m|=0x01; 192 if (mode&S_IRUSR) m|=0x01;
128 if (mode&S_IWUSR) m|=0x02; 193 if (mode&S_IWUSR) m|=0x02;
129 if (mode&S_IXUSR) m|=0x04; 194 if (mode&S_IXUSR) m|=0x04;
132 if (mode&S_IXOTH) m|=0x20; 197 if (mode&S_IXOTH) m|=0x20;
133 m|=0x60; // always sharable 198 m|=0x60; // always sharable
134 *os9mode = m; 199 *os9mode = m;
135 } 200 }
136 201
137 char * os9toUnixAttr(Byte attr) { 202 static char *
203 os9toUnixAttr(Byte attr) {
138 if ((attr&0x1) && (attr&0x2)) return "r+"; 204 if ((attr&0x1) && (attr&0x2)) return "r+";
139 if (!(attr&0x1) && (attr&0x2)) return "w"; 205 if (!(attr&0x1) && (attr&0x2)) return "w";
140 if ((attr&0x1) && !(attr&0x2)) return "r"; 206 if ((attr&0x1) && !(attr&0x2)) return "r";
141 return "r"; 207 return "r";
142 } 208 }
187 #define DIR_SZ 32 253 #define DIR_SZ 32
188 #define DIR_NM 29 254 #define DIR_NM 29
189 255
190 256
191 /* read direcotry entry */ 257 /* read direcotry entry */
192 int os9opendir(PathDesc *pd) { 258 static int
259 os9opendir(PathDesc *pd) {
193 DIR *dir; 260 DIR *dir;
194 struct dirent *dp; 261 struct dirent *dp;
195 if (pd->dirfp) return 0; // already opened 262 if (pd->dirfp) return 0; // already opened
196 dir = opendir(pd->name); 263 dir = opendir(pd->name);
197 if (dir==0) return -1; 264 if (dir==0) return -1;
220 } 287 }
221 pd->fp = fmemopen(pd->dirfp,pd->sz,"r"); 288 pd->fp = fmemopen(pd->dirfp,pd->sz,"r");
222 return 0; 289 return 0;
223 } 290 }
224 291
225 void os9setdate(char *d,struct timespec * unixtime) { 292 static void
293 os9setdate(char *d,struct timespec * unixtime) {
226 // yymmddhhss 294 // yymmddhhss
227 struct tm r; 295 struct tm r;
228 localtime_r(&unixtime->tv_sec,&r); 296 localtime_r(&unixtime->tv_sec,&r);
229 d[0] = r.tm_year-2000; 297 d[0] = r.tm_year-2000;
230 d[1] = r.tm_mon; 298 d[1] = r.tm_mon;
236 304
237 /* read file descriptor of Path Desc 305 /* read file descriptor of Path Desc
238 * create file descriptor sector if necessary 306 * create file descriptor sector if necessary
239 * if buf!=0, copy it 307 * if buf!=0, copy it
240 */ 308 */
241 int filedescriptor(Byte *buf, int len, PathDesc *pd) { 309 static int
310 filedescriptor(Byte *buf, int len, PathDesc *pd) {
242 struct stat st; 311 struct stat st;
243 if (pd->fd) return 1; 312 if (pd->fd) return 1;
244 pd->fd = (char *)malloc(256); 313 pd->fd = (char *)malloc(256);
245 stat(pd->name,&st); 314 stat(pd->name,&st);
246 os9setmode(pd->fd+FD_ATT,st.st_mode); 315 os9setmode(pd->fd+FD_ATT,st.st_mode);
247 pd->fd[FD_OWN]=(st.st_uid&0xff00)>>8; 316 pd->fd[FD_OWN]=(st.st_uid&0xff00)>>8;
248 pd->fd[FD_OWN+1]=st.st_uid&0xff; 317 pd->fd[FD_OWN+1]=st.st_uid&0xff;
249 os9setdate(pd->fd + FD_DAT,&st.st_mtimespec); 318 os9setdate(pd->fd + FD_DAT,&st.st_mtimespec);
250 pd->fd[FD_LNK+0]=(st.st_uid&0xff000000)>>24; 319 pd->fd[FD_LNK]=st.st_nlink&0xff;
251 pd->fd[FD_LNK+1]=(st.st_uid&0xff0000)>>16; 320 pd->fd[FD_SIZ+0]=(st.st_size&0xff000000)>>24;
252 pd->fd[FD_LNK+2]=(st.st_uid&0xff00)>>8; 321 pd->fd[FD_SIZ+1]=(st.st_size&0xff0000)>>16;
253 pd->fd[FD_LNK+3]=st.st_nlink&0xff; 322 pd->fd[FD_SIZ+2]=(st.st_size&0xff00)>>8;
323 pd->fd[FD_SIZ+3]=st.st_size&0xff;
254 os9setdate(pd->fd+FD_Creat,&st.st_ctimespec); 324 os9setdate(pd->fd+FD_Creat,&st.st_ctimespec);
255 // dummy segment list 325 // dummy segment list
256 for(int i=FD_SEG ; i < 256; i++) pd->fd[i] = 0; 326 for(int i=FD_SEG ; i < 256; i++) pd->fd[i] = 0;
257 return 0; 327 return 0;
258 } 328 }
261 * we only returns a file descriptor only in the current opened directory 331 * we only returns a file descriptor only in the current opened directory
262 * 332 *
263 * inode==0 should return disk id section 333 * inode==0 should return disk id section
264 * inode==bitmap should return disk sector map for os9 free command 334 * inode==bitmap should return disk sector map for os9 free command
265 */ 335 */
266 int fdinfo(Byte *buf,int len, int inode, PathDesc *pd) { 336 static int
337 fdinfo(Byte *buf,int len, int inode, PathDesc *pd) {
267 int i; 338 int i;
268 for(i=0;i<MAXPDV;i++) { 339 for(i=0;i<MAXPDV;i++) {
269 PathDesc *pd = pdv+i; 340 PathDesc *pd = pdv+i;
270 if (!pd->use || !pd->dir) continue; 341 if (!pd->use || !pd->dir) continue;
271 // find inode in directory 342 // find inode in directory
272 char *dir = (char *)pd->dirfp; 343 char *dir = (char *)pd->dirfp;
273 while( dir < dir + pd->sz ) { 344 char *end = (char *)pd->dirfp + pd->sz;
345 while( dir < end ) {
274 Byte *p = (Byte *)(dir + DIR_NM); 346 Byte *p = (Byte *)(dir + DIR_NM);
275 int dinode = (p[0]<<16)+(p[1]<<8)+p[2]; 347 int dinode = (p[0]<<16)+(p[1]<<8)+p[2];
276 if (inode == dinode) { 348 if (inode == dinode) {
277 filedescriptor(buf,len,pd); 349 filedescriptor(buf,len,pd);
278 return 1; 350 return 1;
279 } 351 }
352 dir += 0x20;
280 } 353 }
281 } 354 }
282 return 0; 355 return 0;
283 } 356 }
284 357
285 /* 358 /*
286 * each command should have preallocated os9 path descriptor on Y 359 * each command should have preallocated os9 path descriptor on Y
287 * 360 *
288 * name or buffer, can be in a user map, pmem check that drive number ( mem[0x41+IOPAGE] 0 sys 1 user ) 361 * name or buffer, can be in a user map, check that drive number ( mem[0x41+IOPAGE] 0 sys 1 user )
289 * current directory path number mem[0x42+IOPAGE] 362 * current directory path number mem[0x42+IOPAGE]
290 * yreg has pd number 363 * yreg has pd number
291 */ 364 */
292 void do_vdisk(Byte cmd) { 365 void
366 do_vdisk(Byte cmd) {
293 int err; 367 int err;
294 PathDesc *curdir = pdv+mem[0x44+IOPAGE]; // garbage until set 368 int curdir = mem[0x44+IOPAGE]; // garbage until set
295 Byte attr ; 369 Byte attr ;
296 Word u = (mem[0x45+IOPAGE]<<8)+mem[0x46+IOPAGE]; // caller's stack in system segment 370 Word u = getword(&mem[0x45+IOPAGE]); // caller's stack in system segment
297 xreg = (*smem(u+4)<<8)+*smem(u+5); 371 Byte *frame = smem(u);
298 yreg = (*smem(u+6)<<8)+*smem(u+7); 372 xreg = getword(frame+4);
373 yreg = getword(frame+6);
299 *areg = *smem(u+1); 374 *areg = *smem(u+1);
300 *breg = *smem(u+2); 375 *breg = *smem(u+2);
301 Byte mode = yreg&0xff; 376 Byte mode = 0;
302 Byte *os9pd = smem((mem[0x47+IOPAGE]<<8)+mem[0x48+IOPAGE]); 377 Byte *os9pd = smem(getword(&mem[0x47+IOPAGE]));
303 PathDesc *pd = pdv+*os9pd; 378 PathDesc *pd = pdv+*os9pd;
304 pd->num = *os9pd; 379 pd->num = *os9pd;
305 pd->drv = mem[0x41+IOPAGE]; 380 pd->drv = mem[0x41+IOPAGE];
306 char *path,*next,*buf; 381 char *path,*next,*buf;
382 if (vdiskdebug&1) vdisklog(u,pd,getword(&mem[0x47+IOPAGE]),curdir,stdout);
307 383
308 switch(cmd) { 384 switch(cmd) {
309 /* 385 /*
310 * I$Create Entry Point 386 * I$Create Entry Point
311 * 387 *
369 pd->use = 1; 445 pd->use = 1;
370 } 446 }
371 if (next!=0 && pd->fp !=0) { 447 if (next!=0 && pd->fp !=0) {
372 *breg = 0; 448 *breg = 0;
373 *areg = pd->num; 449 *areg = pd->num;
450 *smem(u+1) = *areg ;
374 xreg += ( next - path ); 451 xreg += ( next - path );
375 pd->use = 1; 452 pd->use = 1;
376 } else { 453 } else {
377 pd->use = 0; 454 pd->use = 0;
378 } 455 }
419 * Exit: X = last byte of pathlist address 496 * Exit: X = last byte of pathlist address
420 * A = open directory Path Number 497 * A = open directory Path Number
421 * 498 *
422 * Error: CC Carry set 499 * Error: CC Carry set
423 * B = errcode 500 * B = errcode
501 *
502 *
503 * we keep track a cwd and a cxd for a process using 8bit id
424 */ 504 */
425 case 0xd4: 505 case 0xd4:
426 path = (char*)umem(xreg); 506 path = (char*)umem(xreg);
427 next = checkFileName(path,pd,curdir); 507 next = checkFileName(path,pd,curdir);
428 if (next!=0 && os9opendir(pd)==0) { 508 if (next!=0) {
429 if (curdir!=pd) closepd(curdir); 509 struct stat buf;
510 if (stat(pd->name,&buf)!=0) break;
511 if ((buf.st_mode & S_IFMT) != S_IFDIR) break;
430 xreg += ( next - path ); 512 xreg += ( next - path );
431 *areg = pd->num; 513 *areg = setcd(pd->name);
514 *smem(u+1) = *areg ;
432 pd->use = 1; 515 pd->use = 1;
516 pd->dir = 1;
433 *breg = 0; 517 *breg = 0;
434 break; 518 break;
435 } 519 }
436 *breg = 0xff; 520 *breg = 0xff;
437 break; 521 break;
465 * I$Seek Entry Point 549 * I$Seek Entry Point
466 * 550 *
467 * Entry Conditions 551 * Entry Conditions
468 * A path number 552 * A path number
469 * X MS 16 bits of the desired file position 553 * X MS 16 bits of the desired file position
470 * Y LS 16 bits of the desired file position 554 * U LS 16 bits of the desired file position
471 * 555 *
472 * Exit: 556 * Exit:
473 * 557 *
474 * Error: CC Carry set 558 * Error: CC Carry set
475 * B = errcode 559 * B = errcode
476 */ 560 */
477 case 0xd6: { 561 case 0xd6: {
478 *breg = 0xff; 562 *breg = 0xff;
479 off_t seek = (xreg<<16)+yreg; 563 ureg = (*smem(u+8)<<8)+*smem(u+9);
564 off_t seek = (xreg<<16)+ureg;
480 *breg = fseek(pd->fp,(off_t)seek,SEEK_SET); 565 *breg = fseek(pd->fp,(off_t)seek,SEEK_SET);
481 break; 566 break;
482 } 567 }
483 /* 568 /*
484 * I$ReadLn Entry Point 569 * I$ReadLn Entry Point
501 case 0xd7: 586 case 0xd7:
502 *breg = 0xff; 587 *breg = 0xff;
503 buf = (char*)umem(xreg); 588 buf = (char*)umem(xreg);
504 char *b; 589 char *b;
505 if ((b=fgets(buf,yreg,pd->fp))) { 590 if ((b=fgets(buf,yreg,pd->fp))) {
506 // set y
507 *smem(u+6) = (err>>8)&0xff;
508 *smem(u+7) = err&0xff;
509 if (b==0) { 591 if (b==0) {
510 *breg = 0xd3; 592 *breg = 0xd3;
511 break; 593 break;
512 } 594 }
513 int len = err;
514 int i; 595 int i;
515 for(i=0;i<len && buf[i];i++); 596 for(i=0;i<yreg && buf[i];i++);
516 if (i>0 && buf[i-1]=='\n') { 597 if (i>0 && buf[i-1]=='\n') {
517 buf[i-1] = '\r'; 598 buf[i-1] = '\r';
518 yreg = i; 599 yreg = i;
519 } 600 }
601 // set y
602 setword(smem(u+6),yreg);
520 *breg = 0; 603 *breg = 0;
521 } 604 }
522 break; 605 break;
523 606
524 /* 607 /*
534 case 0xd8: 617 case 0xd8:
535 *breg = 0xff; 618 *breg = 0xff;
536 buf = (char*)umem(xreg); 619 buf = (char*)umem(xreg);
537 int i = fread(buf,1,yreg,pd->fp); 620 int i = fread(buf,1,yreg,pd->fp);
538 // set y 621 // set y
539 *smem(u+6) = (i>>8)&0xff; 622 setword(smem(u+6),i);
540 *smem(u+7) = i&0xff;
541 *breg = (i==0?0xd3:0) ; 623 *breg = (i==0?0xd3:0) ;
542 break; 624 break;
543 625
544 /* 626 /*
545 * I$WritLn Entry Point 627 * I$WritLn Entry Point
570 fputc('\n',pd->fp); 652 fputc('\n',pd->fp);
571 i++; 653 i++;
572 } 654 }
573 *breg = 0; 655 *breg = 0;
574 // set y 656 // set y
575 *smem(u+6) = (i>>8)&0xff; 657 setword(smem(u+6),i);
576 *smem(u+7) = i&0xff;
577 break; 658 break;
578 } 659 }
579 660
580 /* 661 /*
581 * I$Write Entry Point 662 * I$Write Entry Point
591 *breg = 0xff; 672 *breg = 0xff;
592 if (!pd->dir) { 673 if (!pd->dir) {
593 Byte *buf = umem(xreg); 674 Byte *buf = umem(xreg);
594 int len = yreg; 675 int len = yreg;
595 int err = fwrite(buf,1,len,pd->fp); 676 int err = fwrite(buf,1,len,pd->fp);
596 *breg = err?0xff:0; 677 *breg = err?0:0xff;
597 // set y 678 // set y
598 *smem(u+6) = (i>>8)&0xff; 679 setword(smem(u+6),err);
599 *smem(u+7) = i&0xff;
600 } 680 }
601 break; 681 break;
602 682
603 /* I$Close Entry Point 683 /* I$Close Entry Point
604 * 684 *
675 * LSB - MSB of logical sector # 755 * LSB - MSB of logical sector #
676 * R$U= LSW of logical sector # 756 * R$U= LSW of logical sector #
677 */ 757 */
678 *breg = 0xff; 758 *breg = 0xff;
679 if (pd==0) break; 759 if (pd==0) break;
680 ureg = (*smem(u+8)<<8)+*smem(u+9); 760 ureg = getword(smem(u+8));
681 *breg = fdinfo(pmem(xreg),yreg,xreg*0x10000+ureg,pd); 761 *breg = fdinfo(umem(xreg),yreg,xreg*0x10000+ureg,pd);
682 break; 762 break;
683 default: 763 default:
684 *breg = 0xff; 764 *breg = 0xff;
685 } 765 }
686 break; 766 break;
712 break; 792 break;
713 } 793 }
714 // return value 794 // return value
715 mem[0xffc0] = *breg; 795 mem[0xffc0] = *breg;
716 *smem(u+2) = *breg ; 796 *smem(u+2) = *breg ;
717 *smem(u+4) = (xreg & 0xff00) >> 8; 797 setword(smem(u+4),xreg);
718 *smem(u+5) = xreg & 0xff; 798 }
719 799
720 } 800 static void
721 801 vdisklog(Word u,PathDesc *pd, Word pdptr, int curdir, FILE *fp) {
722 802 char *cd = cdt[curdir]?cdt[curdir]:"(null)";
803 fprintf(fp,"pd %d 0x%x cd[%d]=%s ",pd->num, pdptr, curdir,cd);
804 Byte *frame = smem(u);
805 sreg = u;
806 ccreg = frame[0];
807 *areg = frame[1];
808 *breg = frame[2];
809 xreg = getword(frame+4);
810 yreg = getword(frame+6);
811 ureg = getword(frame+8);
812 pcreg = getword(frame+10)-3;
813 prog = (char*)(umem(pcreg) - pcreg);
814 do_trace(fp);
815 }
816
817
818 /* end */