![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fhsys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src|
Return to fhsys.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src |
1.1 root 1: /*
2: * Functions for dealing with filesystem open object handles.
3: */
4: /*
5: *-IMPORTS:
6: * <common/ccompat.h>
7: * __USE_PROTO__
8: * __ARGS ()
9: * <sys/debug.h>
10: * ASSERT ()
11: * <sys/errno.h>
12: * EMFILE
13: * <string.h>
14: * NULL
15: * memcpy ()
16: */
17:
18: #include <common/ccompat.h>
19: #include <sys/debug.h>
20: #include <sys/errno.h>
21: #include <string.h>
22:
23: #include <kernel/fhsys.h>
24:
25:
26: /*
27: * About open file handles; pointers to objects of type "fhandle_t" are used
28: * in the kernel to represent information about abstract open file objects.
29: * The handles contain pointers to tables of entry points to dispatch abstract
30: * operations such as read and write to routines specific to the type of
31: * object that is referred to.
32: *
33: * Unlike the "vnode" VFS system used in System V and BSD Unix, this system
34: * follows the lead of the Sprite operating system in separating the functions
35: * of naming objects and providing the services specific to the different
36: * types of objects that may be named.
37: *
38: * Neither the internal structure of a handle nor the function dispatch table
39: * is available to implementations of file systems, so that file systems can
40: * be written with maximum binary portability.
41: */
42:
43:
44: /*
45: * "fdprocs" structures should be constructed by automated tools like the
46: * device configuration mechanism. As such, users do not get to deal with the
47: * definition of the structure that "fprocs_t" actually refers to.
48: */
49:
50: struct fprocs {
51: fh_open_t fh_open;
52: fh_close_t fh_close;
53: fh_read_t fh_read;
54: fh_write_t fh_write;
55: fh_ioctl_t fh_ioctl;
56: fh_poll_t fh_poll;
57: fh_lseek_t fh_lseek;
58: fh_sync_t fh_sync;
59: fh_getpmsg_t fh_getpmsg;
60: fh_putpmsg_t fh_putpmsg;
61: fh_fstat_t fh_fstat;
62: fh_statvfs_t fh_statvfs;
63: fh_mmap_t fh_mmap;
64: fh_attach_t fh_attach;
65: fh_detach_t fh_detach;
66: };
67:
68:
69: /*
70: * The definition of the body of the "fhandle_t" structure is also kept
71: * totally opaque for maximum binary compatibility between installable
72: * filesystems.
73: */
74:
75:
76: #define FHOPAQUESZ 32
77:
78: struct fhandle {
79: fprocs_t * fh_procs;
80: char fh_opaque [FHOPAQUESZ];
81: };
82:
83:
84: /*
85: * This function looks up a system file table entry based on the file
86: * descriptor number.
87: */
88:
89: #if __USE_PROTO__
90: sftab_t * (fd_get_sftab) (int fd)
91: #else
92: sftab_t *
93: fd_get_sftab __ARGS ((fd))
94: int fd;
95: #endif
96: {
97: return NULL;
98: }
99:
100:
101: /*
102: * This function looks up a file handle based on the file descriptor number.
103: */
104:
105: #if __USE_PROTO__
106: fhandle_t * (fd_get_handle) (int fd)
107: #else
108: fhandle_t *
109: fd_get_handle __ARGS ((fd))
110: int fd;
111: #endif
112: {
113: return NULL;
114: }
115:
116:
117: /*
118: * This function tries to add a file descriptor to the currently running
119: * process as a clone of some existing system file table entry. The file
120: * descriptor number assigned to the file is returned in the value pointed to
121: * by the "fdp" parameter.
122: *
123: * The file descriptor will be default be set to remain open across exec ()
124: * system calls.
125: *
126: * Returns 0 on success, or an error number on failure.
127: */
128:
129: #if __USE_PROTO__
130: int (fd_add_sftab) (sftab_t * sftabp, int * fdp)
131: #else
132: int
133: fd_add_sftab __ARGS ((sftabp, fdp))
134: sftab_t * sftabp;
135: int * fdp;
136: #endif
137: {
138: return EMFILE;
139: }
140:
141:
142: /*
143: * This function tests to see whether it is possible to add a new file entry
144: * to the current process (ie, it attempts to tell whether fd_add_sftab ()
145: * would fail with EMFILE).
146: *
147: * Reutrn 0 on success, or an error number on failure.
148: */
149:
150: #if __USE_PROTO__
151: int (fd_can_add) (void)
152: #else
153: int
154: fd_can_add __ARGS (())
155: #endif
156: {
157: return EMFILE;
158: }
159:
160:
161: /*
162: * This function returns a pointer to the "fprocs" structure member of a file
163: * handle.
164: */
165:
166: #if __USE_PROTO__
167: fprocs_t * (fh_procs) (fhandle_t * handle)
168: #else
169: fprocs_t *
170: fh_procs __ARGS ((handle))
171: fhandle_t * handle;
172: #endif
173: {
174: ASSERT (handle != NULL);
175: ASSERT (handle->fh_procs != NULL);
176:
177: return handle->fh_procs;
178: }
179:
180:
181: /*
182: * This function returns a pointer to the opaque part of the file handle.
183: */
184:
185: #if __USE_PROTO__
186: __VOID__ * (fh_get_cookie) (fhandle_t * handle)
187: #else
188: __VOID__ *
189: fh_get_cookie __ARGS ((handle))
190: fhandle_t * handle;
191: #endif
192: {
193: ASSERT (handle != NULL);
194:
195: return handle->fh_opaque;
196: }
197:
198:
199: /*
200: * This function accepts a pointer to a data area that will be copied into
201: * the file handle somehow. The only guarantee that is made by this function
202: * is that fh_get_cookie () will return a pointer to data that is identical
203: * in value to that passed to this function.
204: *
205: * This function returns 0 on success or non-zero on failure (such as being
206: * unable to allocate space for the cookie).
207: *
208: * May sleep.
209: */
210:
211: #if __USE_PROTO__
212: int (fh_set_cookie) (fhandle_t * handle, __VOID__ * cookie, size_t len)
213: #else
214: int
215: fh_set_cookie __ARGS ((handle, cookie, len))
216: fhandle_t * handle;
217: __VOID__ * cookie;
218: size_t len;
219: #endif
220: {
221: if (len > FHOPAQUESZ || cookie == NULL)
222: return -1;
223:
224: (void) memcpy (handle->fh_opaque, cookie, len);
225: return 0;
226: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.