![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disk_label.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / driverkit / libDriver / ppc|
Return to disk_label.c CVS log | Up to [Apple Darwin 0.x] / driverkit / libDriver / ppc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24: /* Copyright (c) 1992 by NeXT Computer, Inc.
25: *
26: * File: i386/disk_label.c - trivial native (i386) implementation
27: * of disk_label conversion API.
28: *
29: * HISTORY
30: * 01-Apr-92 Doug Mitchell at NeXT
31: * Created.
32: */
33:
34: #import <bsd/dev/disk_label.h>
35: #import <driverkit/diskstruct.h>
36: #import <bsd/string.h>
37: #import <architecture/byte_order.h>
38:
39: static inline void get_char(const char *src, char *dest)
40: {
41: *dest = *src;
42: }
43:
44: static inline void get_short(const char *src, char *dest)
45: {
46: dest[0] = src[0];
47: dest[1] = src[1];
48: }
49:
50: static inline void get_word(const char *src, char *dest)
51: {
52: dest[0] = src[0];
53: dest[1] = src[1];
54: dest[2] = src[2];
55: dest[3] = src[3];
56: }
57:
58: static inline void put_char(const char *src, char *dest)
59: {
60: *dest = *src;
61: }
62:
63: static inline void put_short(const char *src, char *dest)
64: {
65: dest[0] = src[0];
66: dest[1] = src[1];
67: }
68:
69: static inline void put_word(const char *src, char *dest)
70: {
71: dest[0] = src[0];
72: dest[1] = src[1];
73: dest[2] = src[2];
74: dest[3] = src[3];
75: }
76:
77:
78: /*
79: * Convert from native (m68k) disk structs to m88k. Used when reading
80: * from disk.
81: */
82: void get_partition(const char *source, partition_t *dest)
83: {
84: get_word(source + PARTITION_P_BASE, (char *)&dest->p_base);
85: get_word(source + PARTITION_P_SIZE, (char *)&dest->p_size);
86: get_short(source + PARTITION_P_BSIZE, (char *)&dest->p_bsize);
87: get_short(source + PARTITION_P_FSIZE, (char *)&dest->p_fsize);
88: get_char(source + PARTITION_P_OPT, (char *)&dest->p_opt);
89: get_short(source + PARTITION_P_CPG, (char *)&dest->p_cpg);
90: get_short(source + PARTITION_P_DENSITY, (char *)&dest->p_density);
91: get_char(source + PARTITION_P_MINFREE, (char *)&dest->p_minfree);
92: get_char(source + PARTITION_P_NEWFS, (char *)&dest->p_newfs);
93: bcopy(source + PARTITION_P_MOUNTPT, dest->p_mountpt, MAXMPTLEN);
94: get_char(source + PARTITION_P_AUTOMNT, (char *)&dest->p_automnt);
95: bcopy(source + PARTITION_P_TYPE, dest->p_type, MAXFSTLEN);
96: }
97:
98: void get_disktab(const char *source, disktab_t *dest)
99: {
100: int part_num;
101: int i;
102: unsigned char *bblk_src, *bblk_dst;
103:
104: bcopy(source + DISKTAB_D_NAME, dest->d_name, MAXDNMLEN);
105: bcopy(source + DISKTAB_D_TYPE, dest->d_type, MAXTYPLEN);
106: get_word(source + DISKTAB_D_SECSIZE, (char *)&dest->d_secsize);
107: get_word(source + DISKTAB_D_NTRACKS, (char *)&dest->d_ntracks);
108: get_word(source + DISKTAB_D_NSECTORS, (char *)&dest->d_nsectors);
109: get_word(source + DISKTAB_D_NCYLINDERS, (char *)&dest->d_ncylinders);
110: get_word(source + DISKTAB_D_RPM, (char *)&dest->d_rpm);
111: get_short(source + DISKTAB_D_FRONT, (char *)&dest->d_front);
112: get_short(source + DISKTAB_D_BACK, (char *)&dest->d_back);
113: get_short(source + DISKTAB_D_NGROUPS, (char *)&dest->d_ngroups);
114: get_short(source + DISKTAB_D_AG_SIZE, (char *)&dest->d_ag_size);
115: get_short(source + DISKTAB_D_AG_ALTS, (char *)&dest->d_ag_alts);
116: get_short(source + DISKTAB_D_AG_OFF, (char *)&dest->d_ag_off);
117: if (NBOOTS){
118: bblk_src = (unsigned char *)(source + DISKTAB_D_BOOT0_BLKNO);
119: bblk_dst = (unsigned char *)&dest->d_boot0_blkno;
120: for (i = 0; i < (NBOOTS) ; i++){
121: get_word(bblk_src, bblk_dst);
122: bblk_src += sizeof(int);
123: bblk_dst += sizeof(int);
124: }
125: }
126: bcopy(source + DISKTAB_D_BOOTFILE, dest->d_bootfile, MAXBFLEN);
127: bcopy(source + DISKTAB_D_HOSTNAME, dest->d_hostname, MAXHNLEN);
128: get_char(source + DISKTAB_D_ROOTPARTITION,
129: (char *)&dest->d_rootpartition);
130: get_char(source + DISKTAB_D_RWPARTITION, (char *)&dest->d_rwpartition);
131: for(part_num=0; part_num<NPART; part_num++) {
132: get_partition(source + DISKTAB_D_PARTITIONS +
133: (part_num * SIZEOF_PARTITION_T),
134: &dest->d_partitions[part_num]);
135: }
136: }
137:
138: void get_dl_un(const char *source, dl_un_t *dest)
139: {
140: int i;
141:
142: for(i=0; i<NBAD; i++) {
143: get_word(source, (char *)&dest->DL_bad[i]);
144: source += sizeof(int);
145: }
146: }
147:
148: void get_disk_label(const char *source, disk_label_t *dest)
149: {
150: get_word(source + DISK_LABEL_DL_VERSION, (char *)&dest->dl_version);
151: get_word(source + DISK_LABEL_DL_LABEL_BLKNO,
152: (char *)&dest->dl_label_blkno);
153: get_word(source + DISK_LABEL_DL_SIZE, (char *)&dest->dl_size);
154: bcopy(source + DISK_LABEL_DL_LABEL, dest->dl_label, MAXLBLLEN);
155: get_word(source + DISK_LABEL_DL_FLAGS, (char *)&dest->dl_flags);
156: get_word(source + DISK_LABEL_DL_TAG, (char *)&dest->dl_tag);
157: get_disktab(source + DISK_LABEL_DL_DT, &dest->dl_dt);
158: get_dl_un(source + DISK_LABEL_DL_UN, &dest->dl_un);
159: get_short(source + DISK_LABEL_DL_CHECKSUM, (char *)&dest->dl_checksum);
160: get_short(source + DISK_LABEL_DL_UN, (char *)&dest->dl_v3_checksum);
161: }
162:
163: /*
164: * Convert from m88k disk structs to native (m68k). Used when writing
165: * to disk.
166: */
167: void put_partition(const partition_t *source, char *dest)
168: {
169: put_word((const char *)&source->p_base, dest + PARTITION_P_BASE);
170: put_word((const char *)&source->p_size, dest + PARTITION_P_SIZE);
171: put_short((const char *)&source->p_bsize, dest + PARTITION_P_BSIZE);
172: put_short((const char *)&source->p_fsize, dest + PARTITION_P_FSIZE);
173: put_char((const char *)&source->p_opt, dest + PARTITION_P_OPT);
174: put_short((const char *)&source->p_cpg, dest + PARTITION_P_CPG);
175: put_short((const char *)&source->p_density, dest +
176: PARTITION_P_DENSITY);
177: put_char((const char *)&source->p_minfree, dest + PARTITION_P_MINFREE);
178: put_char((const char *)&source->p_newfs, dest + PARTITION_P_NEWFS);
179: bcopy(source->p_mountpt, dest + PARTITION_P_MOUNTPT, MAXMPTLEN);
180: put_char((const char *)&source->p_automnt, dest + PARTITION_P_AUTOMNT);
181: bcopy(source->p_type, dest + PARTITION_P_TYPE, MAXFSTLEN);
182: }
183:
184: void put_disktab(const disktab_t *source, char *dest)
185: {
186: int part_num;
187: unsigned char *bblk_src, *bblk_dst;
188: int i;
189:
190: bcopy(source->d_name, dest + DISKTAB_D_NAME, MAXDNMLEN);
191: bcopy(source->d_type, dest + DISKTAB_D_TYPE, MAXTYPLEN);
192: put_word((const char *)&source->d_secsize, dest + DISKTAB_D_SECSIZE);
193: put_word((const char *)&source->d_ntracks, dest + DISKTAB_D_NTRACKS);
194: put_word((const char *)&source->d_nsectors, dest + DISKTAB_D_NSECTORS);
195: put_word((const char *)&source->d_ncylinders, dest +
196: DISKTAB_D_NCYLINDERS);
197: put_word((const char *)&source->d_rpm, dest + DISKTAB_D_RPM);
198: put_short((const char *)&source->d_front, dest + DISKTAB_D_FRONT);
199: put_short((const char *)&source->d_back, dest + DISKTAB_D_BACK);
200: put_short((const char *)&source->d_ngroups, dest + DISKTAB_D_NGROUPS);
201: put_short((const char *)&source->d_ag_size, dest + DISKTAB_D_AG_SIZE);
202: put_short((const char *)&source->d_ag_alts, dest + DISKTAB_D_AG_ALTS);
203: put_short((const char *)&source->d_ag_off, dest + DISKTAB_D_AG_OFF);
204: if (NBOOTS){
205: bblk_dst = (unsigned char *)(dest + DISKTAB_D_BOOT0_BLKNO);
206: bblk_src = (unsigned char *)&source->d_boot0_blkno;
207: for (i = 0; i < (NBOOTS) ; i++){
208: put_word(bblk_src, bblk_dst);
209: bblk_src += sizeof(int);
210: bblk_dst += sizeof(int);
211: }
212: }
213: bcopy(source->d_bootfile, dest + DISKTAB_D_BOOTFILE, MAXBFLEN);
214: bcopy(source->d_hostname, dest + DISKTAB_D_HOSTNAME, MAXHNLEN);
215: put_char((const char *)&source->d_rootpartition,
216: dest + DISKTAB_D_ROOTPARTITION);
217: put_char((const char *)&source->d_rwpartition,
218: dest + DISKTAB_D_RWPARTITION);
219: for(part_num=0; part_num<NPART; part_num++) {
220: put_partition(&source->d_partitions[part_num],
221: dest + DISKTAB_D_PARTITIONS +
222: (part_num * SIZEOF_PARTITION_T));
223: }
224: }
225:
226: /*
227: * Warning - this doesn't copy checksum properly. Caller must do that.
228: */
229: void put_dl_un(const dl_un_t *source, char *dest)
230: {
231: int i;
232:
233: for(i=0; i<NBAD; i++) {
234: put_word((const char *)&source->DL_bad[i], dest);
235: dest += sizeof(int);
236: }
237: }
238:
239: void put_disk_label(const disk_label_t *source, char *dest)
240: {
241: put_word((const char *)&source->dl_version,
242: dest + DISK_LABEL_DL_VERSION);
243: put_word((const char *)&source->dl_label_blkno,
244: dest + DISK_LABEL_DL_LABEL_BLKNO);
245: put_word((const char *)&source->dl_size, dest + DISK_LABEL_DL_SIZE);
246: bcopy(source->dl_label, dest + DISK_LABEL_DL_LABEL, MAXLBLLEN);
247: put_word((const char *)&source->dl_flags, dest + DISK_LABEL_DL_FLAGS);
248: put_word((const char *)&source->dl_tag, dest + DISK_LABEL_DL_TAG);
249: put_disktab(&source->dl_dt, dest + DISK_LABEL_DL_DT);
250: put_dl_un(&source->dl_un, dest + DISK_LABEL_DL_UN);
251: put_short((const char *)&source->dl_checksum,
252: dest + DISK_LABEL_DL_CHECKSUM);
253: put_short((const char *)&source->dl_v3_checksum,
254: dest + DISK_LABEL_DL_UN);
255: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.