![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / dev / glue|
Return to misc.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / dev / glue |
1.1 root 1: /*
2: * Miscellaneous routines and data for Linux emulation.
3: *
4: * Copyright (C) 1996 The University of Utah and the Computer Systems
5: * Laboratory at the University of Utah (CSL)
6: *
7: * This program is free software; you can redistribute it and/or modify
8: * it under the terms of the GNU General Public License as published by
9: * the Free Software Foundation; either version 2, or (at your option)
10: * any later version.
11: *
12: * This program is distributed in the hope that it will be useful,
13: * but WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: * GNU General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with this program; if not, write to the Free Software
19: * Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20: *
21: * Author: Shantanu Goel, University of Utah CSL
22: */
23:
24: /*
25: * linux/fs/proc/scsi.c
26: * (c) 1995 Michael Neuffer [email protected]
27: *
28: * The original version was derived from linux/fs/proc/net.c,
29: * which is Copyright (C) 1991, 1992 Linus Torvalds.
30: * Much has been rewritten, but some of the code still remains.
31: *
32: * /proc/scsi directory handling functions
33: *
34: * last change: 95/07/04
35: *
36: * Initial version: March '95
37: * 95/05/15 Added subdirectories for each driver and show every
38: * registered HBA as a single file.
39: * 95/05/30 Added rudimentary write support for parameter passing
40: * 95/07/04 Fixed bugs in directory handling
41: * 95/09/13 Update to support the new proc-dir tree
42: *
43: * TODO: Improve support to write to the driver files
44: * Add some more comments
45: */
46:
47: /*
48: * linux/fs/buffer.c
49: *
50: * Copyright (C) 1991, 1992 Linus Torvalds
51: */
52:
53: #include <sys/types.h>
54: #include <mach/vm_param.h>
55: #include <kern/thread.h>
56: #include <vm/vm_map.h>
57: #include <vm/vm_page.h>
58: #include <device/device_types.h>
59:
60: #define MACH_INCLUDE
61: #include <linux/types.h>
62: #include <linux/config.h>
63: #include <linux/errno.h>
64: #include <linux/mm.h>
65: #include <linux/fs.h>
66: #include <linux/blk.h>
67: #include <linux/proc_fs.h>
68: #include <linux/kernel_stat.h>
69:
70: extern boolean_t vm_map_lookup_entry (register vm_map_t, register vm_offset_t,
71: vm_map_entry_t *);
72: extern int printf (const char *, ...);
73:
74: int (*dispatch_scsi_info_ptr) (int ino, char *buffer, char **start,
75: off_t offset, int length, int inout) = 0;
76:
77: struct kernel_stat kstat;
78:
79: int
80: linux_to_mach_error (int err)
81: {
82: switch (err)
83: {
84: case 0:
85: return D_SUCCESS;
86:
87: case -LINUX_EPERM:
88: return D_INVALID_OPERATION;
89:
90: case -LINUX_EIO:
91: return D_IO_ERROR;
92:
93: case -LINUX_ENXIO:
94: return D_NO_SUCH_DEVICE;
95:
96: case -LINUX_EACCES:
97: return D_INVALID_OPERATION;
98:
99: case -LINUX_EFAULT:
100: return D_INVALID_SIZE;
101:
102: case -LINUX_EBUSY:
103: return D_ALREADY_OPEN;
104:
105: case -LINUX_EINVAL:
106: return D_INVALID_SIZE;
107:
108: case -LINUX_EROFS:
109: return D_READ_ONLY;
110:
111: case -LINUX_EWOULDBLOCK:
112: return D_WOULD_BLOCK;
113:
114: case -LINUX_ENOMEM:
115: return D_NO_MEMORY;
116:
117: default:
118: printf ("linux_to_mach_error: unknown code %d\n", err);
119: return D_IO_ERROR;
120: }
121: }
122:
123: int
124: issig ()
125: {
126: return current_thread ()->wait_result != THREAD_AWAKENED;
127: }
128:
129: int
130: block_fsync (struct inode *inode, struct file *filp)
131: {
132: return 0;
133: }
134:
135: int
136: verify_area (int rw, const void *p, unsigned long size)
137: {
138: vm_prot_t prot = (rw == VERIFY_WRITE) ? VM_PROT_WRITE : VM_PROT_READ;
139: vm_offset_t addr = trunc_page ((vm_offset_t) p);
140: vm_size_t len = round_page ((vm_size_t) size);
141: vm_map_entry_t entry;
142:
143: vm_map_lock_read (current_map ());
144:
145: while (1)
146: {
147: if (!vm_map_lookup_entry (current_map (), addr, &entry)
148: || (entry->protection & prot) != prot)
149: {
150: vm_map_unlock_read (current_map ());
151: return -LINUX_EFAULT;
152: }
153: if (entry->vme_end - entry->vme_start >= len)
154: break;
155: len -= entry->vme_end - entry->vme_start;
156: addr += entry->vme_end - entry->vme_start;
157: }
158:
159: vm_map_unlock_read (current_map ());
160: return 0;
161: }
162:
163: /*
164: * Print device name (in decimal, hexadecimal or symbolic) -
165: * at present hexadecimal only.
166: * Note: returns pointer to static data!
167: */
168: char *
169: kdevname (kdev_t dev)
170: {
171: static char buffer[32];
172: linux_sprintf (buffer, "%02x:%02x", MAJOR (dev), MINOR (dev));
173: return buffer;
174: }
175:
176: /* RO fail safe mechanism */
177:
178: static long ro_bits[MAX_BLKDEV][8];
179:
180: int
181: is_read_only (kdev_t dev)
182: {
183: int minor, major;
184:
185: major = MAJOR (dev);
186: minor = MINOR (dev);
187: if (major < 0 || major >= MAX_BLKDEV)
188: return 0;
189: return ro_bits[major][minor >> 5] & (1 << (minor & 31));
190: }
191:
192: void
193: set_device_ro (kdev_t dev, int flag)
194: {
195: int minor, major;
196:
197: major = MAJOR (dev);
198: minor = MINOR (dev);
199: if (major < 0 || major >= MAX_BLKDEV)
200: return;
201: if (flag)
202: ro_bits[major][minor >> 5] |= 1 << (minor & 31);
203: else
204: ro_bits[major][minor >> 5] &= ~(1 << (minor & 31));
205: }
206:
207: /*
208: * linux/lib/string.c
209: *
210: * Copyright (C) 1991, 1992 Linus Torvalds
211: */
212:
213: /*
214: * stupid library routines.. The optimized versions should generally be found
215: * as inline code in <asm-xx/string.h>
216: *
217: * These are buggy as well..
218: */
219:
220: #include <linux/types.h>
221: #include <linux/string.h>
222:
223: char *___strtok = NULL;
224:
225: #ifndef __HAVE_ARCH_STRSPN
226: size_t
227: strspn (const char *s, const char *accept)
228: {
229: const char *p;
230: const char *a;
231: size_t count = 0;
232:
233: for (p = s; *p != '\0'; ++p)
234: {
235: for (a = accept; *a != '\0'; ++a)
236: {
237: if (*p == *a)
238: break;
239: }
240: if (*a == '\0')
241: return count;
242: ++count;
243: }
244:
245: return count;
246: }
247: #endif
248:
249: #ifndef __HAVE_ARCH_STRPBRK
250: char *
251: strpbrk (const char *cs, const char *ct)
252: {
253: const char *sc1, *sc2;
254:
255: for (sc1 = cs; *sc1 != '\0'; ++sc1)
256: {
257: for (sc2 = ct; *sc2 != '\0'; ++sc2)
258: {
259: if (*sc1 == *sc2)
260: return (char *) sc1;
261: }
262: }
263: return NULL;
264: }
265: #endif
266:
267: #ifndef __HAVE_ARCH_STRTOK
268: char *
269: strtok (char *s, const char *ct)
270: {
271: char *sbegin, *send;
272:
273: sbegin = s ? s : ___strtok;
274: if (!sbegin)
275: {
276: return NULL;
277: }
278: sbegin += strspn (sbegin, ct);
279: if (*sbegin == '\0')
280: {
281: ___strtok = NULL;
282: return (NULL);
283: }
284: send = strpbrk (sbegin, ct);
285: if (send && *send != '\0')
286: *send++ = '\0';
287: ___strtok = send;
288: return (sbegin);
289: }
290: #endif
291:
292:
293: #ifndef __HAVE_ARCH_STRSTR
294: char *
295: strstr (const char *s1, const char *s2)
296: {
297: int l1, l2;
298:
299: l2 = strlen (s2);
300: if (! l2)
301: return (char *) s1;
302: l1 = strlen (s1);
303: while (l1 >= l2)
304: {
305: l1--;
306: if (! memcmp (s1,s2,l2))
307: return (char *) s1;
308: s1++;
309: }
310: return NULL;
311: }
312: #endif
313:
314: struct proc_dir_entry proc_scsi;
315: struct inode_operations proc_scsi_inode_operations;
316: struct proc_dir_entry proc_net;
317: struct inode_operations proc_net_inode_operations;
318:
319: int
320: proc_register (struct proc_dir_entry *xxx1, struct proc_dir_entry *xxx2)
321: {
322: return 0;
323: }
324:
325: int
326: proc_unregister (struct proc_dir_entry *xxx1, int xxx2)
327: {
328: return 0;
329: }
330:
331: void
332: add_blkdev_randomness (int major)
333: {
334: }
335:
336: void
337: do_gettimeofday (struct timeval *tv)
338: {
339: host_get_time (1, tv);
340: }
341:
342: int
343: dev_get_info (char *buffer, char **start, off_t offset, int length, int dummy)
344: {
345: return 0;
346: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.