开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
SYS.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：12k
源码类别：

操作系统开发

开发平台：

DOS

SYS.C：源码内容
  2. /****************************************************************/
  3. /* */
  4. /*       sys.c */
  5. /*       DOS-C */
  6. /* */
  7. /*        sys utility for DOS-C */
  8. /* */
  9. /* Copyright (c) 1991 */
  10. /* Pasquale J. Villani */
  11. /* All Rights Reserved */
  12. /* */
  13. /* This file is part of DOS-C. */
  14. /* */
  15. /* DOS-C is free software; you can redistribute it and/or */
  16. /* modify it under the terms of the GNU General Public License */
  17. /* as published by the Free Software Foundation; either version */
  18. /* 2, or (at your option) any later version. */
  19. /* */
  20. /* DOS-C is distributed in the hope that it will be useful, but */
  21. /* WITHOUT ANY WARRANTY; without even the implied warranty of */
  22. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See */
  23. /* the GNU General Public License for more details. */
  24. /* */
  25. /* You should have received a copy of the GNU General Public */
  26. /* License along with DOS-C; see the file COPYING.  If not, */
  27. /* write to the Free Software Foundation, 675 Mass Ave, */
  28. /* Cambridge, MA 02139, USA. */
  29. /****************************************************************/
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <fcntl.h>
  34. #include <sys/stat.h>
  35. #include <io.h>
  36. #include <dos.h>
  37. #include <ctype.h>
  38. #include <mem.h>
  39. #include "../../hdr/portab.h"
  40. #include "../../hdr/device.h"
  42. BYTE *pgm = "sys";
  44. BOOL fl_reset(VOID);
  45. COUNT fl_rd_status(WORD);
  46. COUNT fl_read(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  47. COUNT fl_write(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  48. BOOL fl_verify(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  49. BOOL fl_format(WORD, BYTE FAR *);
  50. VOID get_boot(COUNT);
  51. VOID put_boot(COUNT);
  52. BOOL check_space(COUNT, BYTE *);
  53. COUNT ltop(WORD *, WORD *, WORD *, COUNT, COUNT, LONG, byteptr);
  54. BOOL copy(COUNT, BYTE *);
  55. BOOL DiskReset(COUNT);
  56. COUNT DiskRead(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  57. COUNT DiskWrite(WORD, WORD, WORD, WORD, WORD, BYTE FAR *);
  59. /* */
  60. /* special word packing prototypes */
  61. /* */
  62. #ifdef NATIVE
  63. # define getlong(vp, lp) (*(LONG *)(lp)=*(LONG *)(vp))
  64. # define getword(vp, wp) (*(WORD *)(wp)=*(WORD *)(vp))
  65. # define getbyte(vp, bp) (*(BYTE *)(bp)=*(BYTE *)(vp))
  66. # define fgetlong(vp, lp) (*(LONG FAR *)(lp)=*(LONG FAR *)(vp))
  67. # define fgetword(vp, wp) (*(WORD FAR *)(wp)=*(WORD FAR *)(vp))
  68. # define fgetbyte(vp, bp) (*(BYTE FAR *)(bp)=*(BYTE FAR *)(vp))
  69. # define fputlong(lp, vp) (*(LONG FAR *)(vp)=*(LONG FAR *)(lp))
  70. # define fputword(wp, vp) (*(WORD FAR *)(vp)=*(WORD FAR *)(wp))
  71. # define fputbyte(bp, vp) (*(BYTE FAR *)(vp)=*(BYTE FAR *)(bp))
  72. #else
  73. VOID getword(VOID *, WORD *);
  74. VOID getbyte(VOID *, BYTE *);
  75. VOID fgetlong(VOID FAR *, LONG FAR *);
  76. VOID fgetword(VOID FAR *, WORD FAR *);
  77. VOID fgetbyte(VOID FAR *, BYTE FAR *);
  78. VOID fputlong(LONG FAR *, VOID FAR *);
  79. VOID fputword(WORD FAR *, VOID FAR *);
  80. VOID fputbyte(BYTE FAR *, VOID FAR *);
  81. #endif
  83. #define SEC_SIZE 512
  84. #define NDEV 4
  85. #define COPY_SIZE 16384
  86. #define NRETRY 5
  88. static struct media_info
  89. {
  90. ULONG mi_size; /* physical sector size */
  91. UWORD mi_heads; /* number of heads (sides) */
  92. UWORD mi_cyls; /* number of cyl/drive */
  93. UWORD mi_sectors; /* number of sectors/cyl */
  94. ULONG mi_offset; /* relative partition offset */
  95. };
  97. union
  98. {
  99. BYTE bytes[2 * SEC_SIZE];
  100. boot boot_sector;
  101. } buffer;
  103. static struct media_info miarray[NDEV] =
  104. {
  105. {720l, 2, 40, 9, 0l},
  106. {720l, 2, 40, 9, 0l},
  107. {720l, 2, 40, 9, 0l},
  108. {720l, 2, 40, 9, 0l}
  109. };
  111. #define PARTOFF 0x1be
  112. #define N_PART 4
  114. static struct
  115. {
  116. BYTE peBootable;
  117. BYTE peBeginHead;
  118. BYTE peBeginSector;
  119. UWORD peBeginCylinder;
  120. BYTE peFileSystem;
  121. BYTE peEndHead;
  122. BYTE peEndSector;
  123. UWORD peEndCylinder;
  124. LONG peStartSector;
  125. LONG peSectors;
  126. } partition[N_PART];
  128. static int DrvMap[4] = {0, 1, 0x80, 0x81};
  130. COUNT drive, active;
  131. UBYTE newboot[SEC_SIZE], oldboot[SEC_SIZE];
  133. #define SBSIZE 51
  134. #define SBOFFSET 11
  136. #define SIZEOF_PARTENT 16
  138. #define FAT12 0x01
  139. #define FAT16SMALL 0x04
  140. #define EXTENDED 0x05
  141. #define FAT16LARGE 0x06
  143. #define N_RETRY 5
  145. COUNT 
  146. get_part (COUNT drive, COUNT idx)
  147. {
  148. REG retry = N_RETRY;
  149. REG BYTE *p = (BYTE *)&buffer.bytes[PARTOFF + (idx * SIZEOF_PARTENT)];
  150. REG ret;
  151. BYTE packed_byte, pb1;
  153. do
  154. {
  155. ret = fl_read((WORD)DrvMap[drive], (WORD)0, (WORD)0, (WORD)1, (WORD)1, (byteptr)&buffer);
  156. } while (ret != 0 && --retry > 0);
  157. if(ret != 0)
  158. return FALSE;
  159. getbyte((VOID *)p, &partition[idx].peBootable);
  160. ++p;
  161. getbyte((VOID *)p, &partition[idx].peBeginHead);
  162. ++p;
  163. getbyte((VOID *)p, &packed_byte);
  164. partition[idx].peBeginSector = packed_byte & 0x3f;
  165. ++p;
  166. getbyte((VOID *)p, &pb1);
  167. ++p;
  168. partition[idx].peBeginCylinder = pb1 + ((0xc0 & packed_byte) << 2);
  169. getbyte((VOID *)p, &partition[idx].peFileSystem);
  170. ++p;
  171. getbyte((VOID *)p, &partition[idx].peEndHead);
  172. ++p;
  173. getbyte((VOID *)p, &packed_byte);
  174. partition[idx].peEndSector = packed_byte & 0x3f;
  175. ++p;
  176. getbyte((VOID *)p, &pb1);
  177. ++p;
  178. partition[idx].peEndCylinder = pb1 + ((0xc0 & packed_byte) << 2);
  179. getlong((VOID *)p, &partition[idx].peStartSector);
  180. p += sizeof(LONG);
  181. getlong((VOID *)p, &partition[idx].peSectors);
  182. return TRUE;
  183. }
  186. VOID main(argc, argv)
  187. COUNT argc;
  188. BYTE *argv[];
  189. {
  190. if(argc != 2)
  191. {
  192. fprintf(stderr, "Useage: %s driven drive = A,B,etc.n", pgm);
  193. exit(1);
  194. }
  196. drive = *argv[1] - (islower(*argv[1]) ? 'a' : 'A');
  197. if(drive < 0 || drive >= NDEV)
  198. {
  199. fprintf(stderr, "%s: drive out of rangen", pgm);
  200. exit(1);
  201. }
  203. if(!DiskReset(drive))
  204. {
  205. fprintf(stderr, "%s: cannot reset drive %c:",
  206. drive, 'A' + drive);
  207. exit(1);
  208. }
  210. get_boot(drive);
  212. if(!check_space(drive, oldboot))
  213. {
  214. fprintf(stderr, "%s: cannot transfer system filesn", pgm);
  215. exit(1);
  216. }
  218. put_boot(drive);
  220. if(!copy(drive, "ipl.sys"))
  221. {
  222. fprintf(stderr, "%s: cannot copy "IPL.SYS"n", pgm);
  223. exit(1);
  224. }
  225. if(!copy(drive, "kernel.exe"))
  226. {
  227. fprintf(stderr, "%s: cannot copy "KERNEL.EXE"n", pgm);
  228. exit(1);
  229. }
  230. if(!copy(drive, "boot.bin"))
  231. {
  232. fprintf(stderr, "%s: cannot copy "BOOT.BIN"n", pgm);
  233. exit(1);
  234. }
  235. if(!copy(drive, "command.com"))
  236. {
  237. fprintf(stderr, "%s: cannot copy "COMMAND.COM"n", pgm);
  238. exit(1);
  239. }
  240. exit(0);
  241. }
  244. VOID put_boot(drive)
  245. COUNT drive;
  246. {
  247. COUNT i;
  248. COUNT ifd;
  249. WORD head, track, sector, ret;
  250. WORD count;
  252. if(drive >= 2)
  253. {
  254. head = partition[active].peBeginHead;
  255. sector = partition[active].peBeginSector;
  256. track = partition[active].peBeginCylinder;
  257. }
  258. else
  259. {
  260. head = 0;
  261. sector = 1;
  262. track = 0;
  263. }
  265. if((ifd = open("boot.bin", O_RDONLY | O_BINARY)) < 0)
  266. {
  267. fprintf(stderr, "%s: can't open"boot.bin"n", pgm);
  268. exit(1);
  269. }
  271. if(read(ifd, newboot, SEC_SIZE) < SEC_SIZE)
  272. {
  273. fprintf(stderr, "%s: error read "boot.bin"", pgm);
  274. exit(1);
  275. }
  277. close(ifd);
  279. if((i = DiskRead(DrvMap[drive], head, track, sector, 1, (BYTE far *)oldboot)) != 0)
  280. {
  281. fprintf(stderr, "%s: disk read error (code = 0x%02x)n", pgm, i & 0xff);
  282. exit(1);
  283. }
  285. memcpy(&newboot[SBOFFSET], &oldboot[SBOFFSET], SBSIZE);
  287. if((i = DiskWrite(DrvMap[drive], head, track, sector, 1, (BYTE far *)newboot)) != 0)
  288. {
  289. fprintf(stderr, "%s: disk write error (code = 0x%02x)n", pgm, i & 0xff);
  290. exit(1);
  291. }
  292. }
  295. VOID get_boot(drive)
  296. COUNT drive;
  297. {
  298. COUNT i;
  299. COUNT ifd;
  300. WORD head, track, sector, ret;
  301. WORD count;
  303. if(drive >= 2)
  304. {
  305. head = partition[active].peBeginHead;
  306. sector = partition[active].peBeginSector;
  307. track = partition[active].peBeginCylinder;
  308. }
  309. else
  310. {
  311. head = 0;
  312. sector = 1;
  313. track = 0;
  314. }
  316. if((i = DiskRead(DrvMap[drive], head, track, sector, 1, (BYTE far *)oldboot)) != 0)
  317. {
  318. fprintf(stderr, "%s: disk read error (code = 0x%02x)n", pgm, i & 0xff);
  319. exit(1);
  320. }
  321. }
  324. BOOL check_space(drive, BlkBuffer)
  325. COUNT drive;
  326. BYTE *BlkBuffer;
  327. {
  328. BYTE *bpbp;
  329. BYTE nfat;
  330. UWORD nfsect;
  331. ULONG hidden, count;
  332. ULONG block;
  333. UBYTE nreserved;
  334. UCOUNT i;
  335. WORD track, head, sector;
  336. UBYTE buffer[SEC_SIZE];
  337. ULONG bpb_huge;
  338. UWORD bpb_nsize;
  340. /* get local information */
  341. getbyte((VOID *)&BlkBuffer[BT_BPB + BPB_NFAT], &nfat);
  342. getword((VOID *)&BlkBuffer[BT_BPB + BPB_NFSECT], &nfsect);
  343. getlong((VOID *)&BlkBuffer[BT_BPB + BPB_HIDDEN], &hidden);
  344. getbyte((VOID *)&BlkBuffer[BT_BPB + BPB_NRESERVED], &nreserved);
  346. getlong((VOID *)&BlkBuffer[BT_BPB + BPB_HUGE], &bpb_huge);
  347. getword((VOID *)&BlkBuffer[BT_BPB + BPB_NSIZE], &bpb_nsize);
  349. count = miarray[drive].mi_size = bpb_nsize == 0 ?
  350.  bpb_huge : bpb_nsize;
  352. /* Fix media information for disk */
  353. getword((&(((BYTE *)&BlkBuffer[BT_BPB])[BPB_NHEADS])), &miarray[drive].mi_heads);
  354. head = miarray[drive].mi_heads;
  355. getword((&(((BYTE *)&BlkBuffer[BT_BPB])[BPB_NSECS])), &miarray[drive].mi_sectors);
  356. if(miarray[drive].mi_size == 0)
  357. getlong(&((((BYTE *)&BlkBuffer[BT_BPB])[BPB_HUGE])), &miarray[drive].mi_size);
  358. sector = miarray[drive].mi_sectors;
  359. if(head == 0 || sector == 0)
  360. {
  361. fprintf(stderr, "Drive initialization failuren");
  362. exit(1);
  363. }
  364. miarray[drive].mi_cyls = count / (head * sector);
  366. return;
  367. }
  369. /* */
  370. /* Do logical block number to physical head/track/sector mapping */
  371. /* */
  372. static COUNT ltop(trackp, sectorp, headp, unit, count, strt_sect, strt_addr)
  373. WORD *trackp, *sectorp, *headp;
  374. REG COUNT unit;
  375. LONG strt_sect;
  376. COUNT count;
  377. byteptr strt_addr;
  378. {
  379. #ifdef I86
  380. ULONG ltemp;
  381. #endif
  382. REG ls, ps;
  384. #ifdef I86
  385. /* Adjust for segmented architecture */
  386. ltemp = (((ULONG)mk_segment(strt_addr) << 4) + mk_offset(strt_addr)) & 0xffff;
  387. /* Test for 64K boundary crossing and return count large */
  388. /* enough not to exceed the threshold. */
  389. count = (((ltemp + SEC_SIZE * count) & 0xffff0000l) != 0l)
  390. ? (0xffffl - ltemp) / SEC_SIZE
  391. : count;
  392. #endif
  394. *trackp = strt_sect / (miarray[unit].mi_heads * miarray[unit].mi_sectors);
  395. *sectorp = strt_sect % miarray[unit].mi_sectors + 1;
  396. *headp = (strt_sect % (miarray[unit].mi_sectors * miarray[unit].mi_heads))
  397. / miarray[unit].mi_sectors;
  398. if(((ls = *headp * miarray[unit].mi_sectors + *sectorp - 1) + count) >
  399. (ps = miarray[unit].mi_heads * miarray[unit].mi_sectors))
  400. count = ps - ls;
  401. return count;
  402. }
  405. BOOL copy(drive, file)
  406. COUNT drive;
  407. BYTE *file;
  408. {
  409. BYTE dest[64];
  410. COUNT ifd, ofd, ret;
  411. BYTE buffer[COPY_SIZE];
  412. struct ftime ftime;
  414. sprintf(dest, "%c:\%s", 'A'+drive, file);
  415. if((ifd = open((BYTE FAR *)file, O_RDONLY | O_BINARY)) < 0)
  416. {
  417. fprintf(stderr, "%s: "%s" not foundn", pgm, file);
  418. return FALSE;
  419. }
  420. _fmode = O_BINARY;
  421. if((ofd = creat((BYTE FAR *)dest, S_IREAD | S_IWRITE)) < 0)
  422. {
  423. fprintf(stderr, "%s: can't create"%s"n", pgm, dest);
  424. return FALSE;
  425. }
  426. while((ret = read(ifd, (VOID *)buffer, COPY_SIZE)) == COPY_SIZE)
  427. write(ofd, (VOID *)buffer, ret);
  428. if(ret >= 0)
  429. write(ofd, (VOID *)buffer, ret);
  430. getftime(ifd, &ftime);
  431. setftime(ofd, &ftime);
  432. close(ifd);
  433. close(ofd);
  434. return TRUE;
  435. }
  438. BOOL DiskReset(COUNT Drive)
  439. {
  440. REG COUNT idx;
  442. /* Reset the drives */
  443. fl_reset();
  445. if(Drive >= 2 && Drive < NDEV)
  446. {
  447. COUNT RetCode;
  449. /* Retrieve all the partition information */
  450. for(RetCode = TRUE, idx = 0; RetCode && (idx < N_PART); idx++)
  451. RetCode = get_part(Drive, idx);
  452. if(!RetCode)
  453. return FALSE;
  455. /* Search for the first DOS partition and start */
  456. /* building the map for the hard drive */
  457. for(idx = 0; idx < N_PART; idx++)
  458. {
  459. if(partition[idx].peFileSystem == FAT12
  460. || partition[idx].peFileSystem == FAT16SMALL
  461. || partition[idx].peFileSystem == FAT16LARGE)
  462. {
  463. miarray[Drive].mi_offset
  464.  = partition[idx].peStartSector;
  465. active = idx;
  466. break;
  467. }
  468. }
  469. }
  471. return TRUE;
  472. }
  474. COUNT DiskRead(WORD drive, WORD head, WORD track, WORD sector, WORD count, BYTE FAR *buffer)
  475. {
  476. int nRetriesLeft;
  478. for(nRetriesLeft = NRETRY; nRetriesLeft > 0; --nRetriesLeft)
  479. {
  480. if(fl_read(drive, head, track, sector, count, buffer) == count)
  481. return count;
  482. }
  483. return 0;
  484. }
  486. COUNT DiskWrite(WORD drive, WORD head, WORD track, WORD sector, WORD count, BYTE FAR *buffer)
  487. {
  488. int nRetriesLeft;
  490. for(nRetriesLeft = NRETRY; nRetriesLeft > 0; --nRetriesLeft)
  491. {
  492. if(fl_write(drive, head, track, sector, count, buffer) == count)
  493. return count;
  494. }
  495. return 0;
  496. }