Bug #6 ยป sys.emulation.diff
| ibcs2/i386/ibcs2_fcntl.c 8 Dec 2005 22:31:33 -0000 | ||
|---|---|---|
| 52 | 52 |
static int ioflags2oflags (int); |
| 53 | 53 | |
| 54 | 54 |
static int |
| 55 |
cvt_o_flags(flags) |
|
| 56 |
int flags; |
|
| 55 |
cvt_o_flags(int flags) |
|
| 57 | 56 |
{
|
| 58 | 57 |
int r = 0; |
| 59 | 58 | |
| ... | ... | |
| 73 | 72 |
} |
| 74 | 73 | |
| 75 | 74 |
static void |
| 76 |
cvt_flock2iflock(flp, iflp) |
|
| 77 |
struct flock *flp; |
|
| 78 |
struct ibcs2_flock *iflp; |
|
| 75 |
cvt_flock2iflock(struct flock *flp, struct ibcs2_flock *iflp) |
|
| 79 | 76 |
{
|
| 80 | 77 |
switch (flp->l_type) {
|
| 81 | 78 |
case F_RDLCK: |
| ... | ... | |
| 106 | 103 |
#endif |
| 107 | 104 | |
| 108 | 105 |
static void |
| 109 |
cvt_iflock2flock(iflp, flp) |
|
| 110 |
struct ibcs2_flock *iflp; |
|
| 111 |
struct flock *flp; |
|
| 106 |
cvt_iflock2flock(struct ibcs2_flock *iflp, struct flock *flp) |
|
| 112 | 107 |
{
|
| 113 | 108 |
flp->l_start = (off_t)iflp->l_start; |
| 114 | 109 |
flp->l_len = (off_t)iflp->l_len; |
| ... | ... | |
| 129 | 124 | |
| 130 | 125 |
/* convert iBCS2 mode into NetBSD mode */ |
| 131 | 126 |
static int |
| 132 |
ioflags2oflags(flags) |
|
| 133 |
int flags; |
|
| 127 |
ioflags2oflags(int flags) |
|
| 134 | 128 |
{
|
| 135 | 129 |
int r = 0; |
| 136 | 130 |
|
| ... | ... | |
| 150 | 144 | |
| 151 | 145 |
/* convert NetBSD mode into iBCS2 mode */ |
| 152 | 146 |
static int |
| 153 |
oflags2ioflags(flags) |
|
| 154 |
int flags; |
|
| 147 |
oflags2ioflags(int flags) |
|
| 155 | 148 |
{
|
| 156 | 149 |
int r = 0; |
| 157 | 150 |
|
| ibcs2/i386/ibcs2_ioctl.c 8 Dec 2005 22:34:33 -0000 | ||
|---|---|---|
| 127 | 127 |
}; |
| 128 | 128 | |
| 129 | 129 |
static void |
| 130 |
stios2btios(st, bt) |
|
| 131 |
struct ibcs2_termios *st; |
|
| 132 |
struct termios *bt; |
|
| 130 |
stios2btios(struct ibcs2_termios *st, struct termios *bt) |
|
| 133 | 131 |
{
|
| 134 | 132 |
u_long l, r; |
| 135 | 133 | |
| ... | ... | |
| 222 | 220 |
} |
| 223 | 221 | |
| 224 | 222 |
static void |
| 225 |
btios2stios(bt, st) |
|
| 226 |
struct termios *bt; |
|
| 227 |
struct ibcs2_termios *st; |
|
| 223 |
btios2stios(struct termios *bt, struct ibcs2_termios *st) |
|
| 228 | 224 |
{
|
| 229 | 225 |
u_long l, r; |
| 230 | 226 | |
| ... | ... | |
| 312 | 308 |
} |
| 313 | 309 | |
| 314 | 310 |
static void |
| 315 |
stios2stio(ts, t) |
|
| 316 |
struct ibcs2_termios *ts; |
|
| 317 |
struct ibcs2_termio *t; |
|
| 311 |
stios2stio(struct ibcs2_termios *ts, struct ibcs2_termio *t) |
|
| 318 | 312 |
{
|
| 319 | 313 |
t->c_iflag = ts->c_iflag; |
| 320 | 314 |
t->c_oflag = ts->c_oflag; |
| ... | ... | |
| 325 | 319 |
} |
| 326 | 320 | |
| 327 | 321 |
static void |
| 328 |
stio2stios(t, ts) |
|
| 329 |
struct ibcs2_termio *t; |
|
| 330 |
struct ibcs2_termios *ts; |
|
| 322 |
stio2stios(struct ibcs2_termio *t, struct ibcs2_termios *ts) |
|
| 331 | 323 |
{
|
| 332 | 324 |
ts->c_iflag = t->c_iflag; |
| 333 | 325 |
ts->c_oflag = t->c_oflag; |
| ibcs2/i386/ibcs2_ipc.c 8 Dec 2005 22:29:14 -0000 | ||
|---|---|---|
| 65 | 65 |
*/ |
| 66 | 66 | |
| 67 | 67 |
static void |
| 68 |
cvt_msqid2imsqid(bp, ibp) |
|
| 69 |
struct msqid_ds *bp; |
|
| 70 |
struct ibcs2_msqid_ds *ibp; |
|
| 68 |
cvt_msqid2imsqid(struct msqid_ds *bp, struct ibcs2_msqid_ds *ibp) |
|
| 71 | 69 |
{
|
| 72 | 70 |
cvt_perm2iperm(&bp->msg_perm, &ibp->msg_perm); |
| 73 | 71 |
ibp->msg_first = bp->msg_first; |
| ... | ... | |
| 84 | 82 |
} |
| 85 | 83 | |
| 86 | 84 |
static void |
| 87 |
cvt_imsqid2msqid(ibp, bp) |
|
| 88 |
struct ibcs2_msqid_ds *ibp; |
|
| 89 |
struct msqid_ds *bp; |
|
| 85 |
cvt_imsqid2msqid(struct ibcs2_msqid_ds *ibp, struct msqid_ds *bp) |
|
| 90 | 86 |
{
|
| 91 | 87 |
cvt_iperm2perm(&ibp->msg_perm, &bp->msg_perm); |
| 92 | 88 |
bp->msg_first = ibp->msg_first; |
| ... | ... | |
| 153 | 149 |
*/ |
| 154 | 150 |
#ifdef unused |
| 155 | 151 |
static void |
| 156 |
cvt_sem2isem(bp, ibp) |
|
| 157 |
struct sem *bp; |
|
| 158 |
struct ibcs2_sem *ibp; |
|
| 152 |
cvt_sem2isem(struct sem *bp, struct ibcs2_sem *ibp) |
|
| 159 | 153 |
{
|
| 160 | 154 |
ibp->semval = bp->semval; |
| 161 | 155 |
ibp->sempid = bp->sempid; |
| ... | ... | |
| 165 | 159 |
} |
| 166 | 160 | |
| 167 | 161 |
static void |
| 168 |
cvt_isem2sem(ibp, bp) |
|
| 169 |
struct ibcs2_sem *ibp; |
|
| 170 |
struct sem *bp; |
|
| 162 |
cvt_isem2sem(struct ibcs2_sem *ibp, struct sem *bp) |
|
| 171 | 163 |
{
|
| 172 | 164 |
bp->semval = ibp->semval; |
| 173 | 165 |
bp->sempid = ibp->sempid; |
| ... | ... | |
| 178 | 170 |
#endif |
| 179 | 171 | |
| 180 | 172 |
static void |
| 181 |
cvt_iperm2perm(ipp, pp) |
|
| 182 |
struct ibcs2_ipc_perm *ipp; |
|
| 183 |
struct ipc_perm *pp; |
|
| 173 |
cvt_iperm2perm(struct ibcs2_ipc_perm *ipp, struct ipc_perm *pp) |
|
| 184 | 174 |
{
|
| 185 | 175 |
pp->uid = ipp->uid; |
| 186 | 176 |
pp->gid = ipp->gid; |
| ... | ... | |
| 192 | 182 |
} |
| 193 | 183 | |
| 194 | 184 |
static void |
| 195 |
cvt_perm2iperm(pp, ipp) |
|
| 196 |
struct ipc_perm *pp; |
|
| 197 |
struct ibcs2_ipc_perm *ipp; |
|
| 185 |
cvt_perm2iperm(struct ipc_perm *pp, struct ibcs2_ipc_perm *ipp) |
|
| 198 | 186 |
{
|
| 199 | 187 |
ipp->uid = pp->uid; |
| 200 | 188 |
ipp->gid = pp->gid; |
| ... | ... | |
| 206 | 194 |
} |
| 207 | 195 | |
| 208 | 196 |
static void |
| 209 |
cvt_semid2isemid(bp, ibp) |
|
| 210 |
struct semid_ds *bp; |
|
| 211 |
struct ibcs2_semid_ds *ibp; |
|
| 197 |
cvt_semid2isemid(struct semid_ds *bp, struct ibcs2_semid_ds *ibp) |
|
| 212 | 198 |
{
|
| 213 | 199 |
cvt_perm2iperm(&bp->sem_perm, &ibp->sem_perm); |
| 214 | 200 |
ibp->sem_base = (struct ibcs2_sem *)bp->sem_base; |
| ... | ... | |
| 219 | 205 |
} |
| 220 | 206 | |
| 221 | 207 |
static void |
| 222 |
cvt_isemid2semid(ibp, bp) |
|
| 223 |
struct ibcs2_semid_ds *ibp; |
|
| 224 |
struct semid_ds *bp; |
|
| 208 |
cvt_isemid2semid(struct ibcs2_semid_ds *ibp, struct semid_ds *bp) |
|
| 225 | 209 |
{
|
| 226 | 210 |
cvt_iperm2perm(&ibp->sem_perm, &bp->sem_perm); |
| 227 | 211 |
bp->sem_base = (struct sem *)ibp->sem_base; |
| ... | ... | |
| 308 | 292 |
*/ |
| 309 | 293 | |
| 310 | 294 |
static void |
| 311 |
cvt_shmid2ishmid(bp, ibp) |
|
| 312 |
struct shmid_ds *bp; |
|
| 313 |
struct ibcs2_shmid_ds *ibp; |
|
| 295 |
cvt_shmid2ishmid(struct shmid_ds *bp, struct ibcs2_shmid_ds *ibp) |
|
| 314 | 296 |
{
|
| 315 | 297 |
cvt_perm2iperm(&bp->shm_perm, &ibp->shm_perm); |
| 316 | 298 |
ibp->shm_segsz = bp->shm_segsz; |
| ... | ... | |
| 325 | 307 |
} |
| 326 | 308 | |
| 327 | 309 |
static void |
| 328 |
cvt_ishmid2shmid(ibp, bp) |
|
| 329 |
struct ibcs2_shmid_ds *ibp; |
|
| 330 |
struct shmid_ds *bp; |
|
| 310 |
cvt_ishmid2shmid(struct ibcs2_shmid_ds *ibp, struct shmid_ds *bp) |
|
| 331 | 311 |
{
|
| 332 | 312 |
cvt_iperm2perm(&ibp->shm_perm, &bp->shm_perm); |
| 333 | 313 |
bp->shm_segsz = ibp->shm_segsz; |
| ibcs2/i386/ibcs2_signal.c 8 Dec 2005 22:33:14 -0000 | ||
|---|---|---|
| 128 | 128 |
}; |
| 129 | 129 | |
| 130 | 130 |
void |
| 131 |
ibcs2_to_bsd_sigset(iss, bss) |
|
| 132 |
const ibcs2_sigset_t *iss; |
|
| 133 |
sigset_t *bss; |
|
| 131 |
ibcs2_to_bsd_sigset(const ibcs2_sigset_t *iss, sigset_t *bss) |
|
| 134 | 132 |
{
|
| 135 | 133 |
int i, newsig; |
| 136 | 134 | |
| ... | ... | |
| 145 | 143 |
} |
| 146 | 144 | |
| 147 | 145 |
static void |
| 148 |
bsd_to_ibcs2_sigset(bss, iss) |
|
| 149 |
const sigset_t *bss; |
|
| 150 |
ibcs2_sigset_t *iss; |
|
| 146 |
bsd_to_ibcs2_sigset(const sigset_t *bss, ibcs2_sigset_t *iss) |
|
| 151 | 147 |
{
|
| 152 | 148 |
int i, newsig; |
| 153 | 149 | |
| ... | ... | |
| 162 | 158 |
} |
| 163 | 159 | |
| 164 | 160 |
static void |
| 165 |
ibcs2_to_bsd_sigaction(isa, bsa) |
|
| 166 |
struct ibcs2_sigaction *isa; |
|
| 167 |
struct sigaction *bsa; |
|
| 161 |
ibcs2_to_bsd_sigaction(struct ibcs2_sigaction *isa, |
|
| 162 |
struct sigaction *bsa) |
|
| 168 | 163 |
{
|
| 169 | 164 | |
| 170 | 165 |
bsa->sa_handler = isa->isa_handler; |
| ... | ... | |
| 175 | 170 |
} |
| 176 | 171 | |
| 177 | 172 |
static void |
| 178 |
bsd_to_ibcs2_sigaction(bsa, isa) |
|
| 179 |
struct sigaction *bsa; |
|
| 180 |
struct ibcs2_sigaction *isa; |
|
| 173 |
bsd_to_ibcs2_sigaction(struct sigaction *bsa, |
|
| 174 |
struct ibcs2_sigaction *isa) |
|
| 181 | 175 |
{
|
| 182 | 176 | |
| 183 | 177 |
isa->isa_handler = bsa->sa_handler; |
| ibcs2/i386/ibcs2_stat.c 8 Dec 2005 22:30:14 -0000 | ||
|---|---|---|
| 55 | 55 |
static int cvt_statfs (struct statfs *, caddr_t, int); |
| 56 | 56 | |
| 57 | 57 |
static void |
| 58 |
bsd_stat2ibcs_stat(st, st4) |
|
| 59 |
struct stat *st; |
|
| 60 |
struct ibcs2_stat *st4; |
|
| 58 |
bsd_stat2ibcs_stat(struct stat *st, struct ibcs2_stat *st4) |
|
| 61 | 59 |
{
|
| 62 | 60 |
bzero(st4, sizeof(*st4)); |
| 63 | 61 |
st4->st_dev = (ibcs2_dev_t)st->st_dev; |
| ... | ... | |
| 77 | 75 |
} |
| 78 | 76 | |
| 79 | 77 |
static int |
| 80 |
cvt_statfs(sp, buf, len) |
|
| 81 |
struct statfs *sp; |
|
| 82 |
caddr_t buf; |
|
| 83 |
int len; |
|
| 78 |
cvt_statfs(struct statfs *sp, caddr_t buf, int len) |
|
| 84 | 79 |
{
|
| 85 | 80 |
struct ibcs2_statfs ssfs; |
| 86 | 81 | |
| ibcs2/i386/ibcs2_util.c 9 Dec 2005 00:07:43 -0000 | ||
|---|---|---|
| 51 | 51 |
* If cflag is set, we check if an attempt can be made to create |
| 52 | 52 |
* the named file, i.e. we check if the directory it should |
| 53 | 53 |
* be in exists. |
| 54 |
* |
|
| 55 |
* Parameters: |
|
| 56 |
* sgp: Pointer to stackgap memory |
|
| 54 | 57 |
*/ |
| 55 | 58 |
int |
| 56 |
ibcs2_emul_find(sgp, prefix, path, pbuf, cflag) |
|
| 57 |
caddr_t *sgp; /* Pointer to stackgap memory */ |
|
| 58 |
const char *prefix; |
|
| 59 |
char *path; |
|
| 60 |
char **pbuf; |
|
| 61 |
int cflag; |
|
| 59 |
ibcs2_emul_find(caddr_t *sgp, const char *prefix, char *path, |
|
| 60 |
char **pbuf, int cflag) |
|
| 62 | 61 |
{
|
| 63 | 62 |
struct nlookupdata nd; |
| 64 | 63 |
struct nlookupdata ndroot; |
| ibcs2/i386/ibcs2_util.h 8 Dec 2005 22:26:29 -0000 | ||
|---|---|---|
| 59 | 59 |
static __inline void *stackgap_alloc(caddr_t *, size_t); |
| 60 | 60 | |
| 61 | 61 |
static __inline caddr_t |
| 62 |
stackgap_init() |
|
| 62 |
stackgap_init(void)
|
|
| 63 | 63 |
{
|
| 64 | 64 |
#define szsigcode (*(curproc->p_sysent->sv_szsigcode)) |
| 65 | 65 |
return (caddr_t)(PS_STRINGS - szsigcode - SPARE_USRSPACE); |
| 66 | 66 |
} |
| 67 | 67 | |
| 68 | 68 |
static __inline void * |
| 69 |
stackgap_alloc(sgp, sz) |
|
| 70 |
caddr_t *sgp; |
|
| 71 |
size_t sz; |
|
| 69 |
stackgap_alloc(caddr_t *sgp, size_t sz) |
|
| 72 | 70 |
{
|
| 73 | 71 |
void *p = (void *) *sgp; |
| 74 | 72 |
*sgp += ALIGN(sz); |
| linux/linux_util.h 8 Dec 2005 22:35:17 -0000 | ||
|---|---|---|
| 70 | 70 |
#define szsigcode(p) (*((p)->p_sysent->sv_szsigcode)) |
| 71 | 71 | |
| 72 | 72 |
static __inline caddr_t |
| 73 |
stackgap_init() |
|
| 73 |
stackgap_init(void)
|
|
| 74 | 74 |
{
|
| 75 | 75 |
return (caddr_t)(PS_STRINGS - szsigcode(curproc) - SPARE_USRSPACE); |
| 76 | 76 |
} |
| 77 | 77 | |
| 78 | 78 |
static __inline void * |
| 79 |
stackgap_alloc(sgp, sz) |
|
| 80 |
caddr_t *sgp; |
|
| 81 |
size_t sz; |
|
| 79 |
stackgap_alloc(caddr_t *sgp, size_t sz) |
|
| 82 | 80 |
{
|
| 83 | 81 |
void *p = (void *) *sgp; |
| 84 | 82 | |
| linux/i386/imgact_linux.c 8 Dec 2005 22:36:55 -0000 | ||
|---|---|---|
| 56 | 56 |
static int exec_linux_imgact (struct image_params *iparams); |
| 57 | 57 | |
| 58 | 58 |
static int |
| 59 |
exec_linux_imgact(imgp) |
|
| 60 |
struct image_params *imgp; |
|
| 59 |
exec_linux_imgact(struct image_params *imgp) |
|
| 61 | 60 |
{
|
| 62 | 61 |
const struct exec *a_out = (const struct exec *) imgp->image_header; |
| 63 | 62 |
struct vmspace *vmspace; |
| linux/i386/linux_sysvec.c 8 Dec 2005 22:36:16 -0000 | ||
|---|---|---|
| 733 | 733 |
static int exec_linux_imgact_try (struct image_params *iparams); |
| 734 | 734 | |
| 735 | 735 |
static int |
| 736 |
exec_linux_imgact_try(imgp) |
|
| 737 |
struct image_params *imgp; |
|
| 736 |
exec_linux_imgact_try(struct image_params *imgp) |
|
| 738 | 737 |
{
|
| 739 | 738 |
const char *head = (const char *)imgp->image_header; |
| 740 | 739 |
int error = -1; |
| linux/i386/linprocfs/linprocfs_misc.c 8 Dec 2005 22:40:57 -0000 | ||
|---|---|---|
| 80 | 80 |
#define P2K(x) ((x) << (PAGE_SHIFT - 10)) /* pages to kbytes */ |
| 81 | 81 | |
| 82 | 82 |
int |
| 83 |
linprocfs_domeminfo(curp, p, pfs, uio) |
|
| 84 |
struct proc *curp; |
|
| 85 |
struct proc *p; |
|
| 86 |
struct pfsnode *pfs; |
|
| 87 |
struct uio *uio; |
|
| 83 |
linprocfs_domeminfo(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 84 |
struct uio *uio) |
|
| 88 | 85 |
{
|
| 89 | 86 |
char *ps; |
| 90 | 87 |
char psbuf[512]; /* XXX - conservative */ |
| ... | ... | |
| 161 | 158 |
} |
| 162 | 159 | |
| 163 | 160 |
int |
| 164 |
linprocfs_docpuinfo(curp, p, pfs, uio) |
|
| 165 |
struct proc *curp; |
|
| 166 |
struct proc *p; |
|
| 167 |
struct pfsnode *pfs; |
|
| 168 |
struct uio *uio; |
|
| 161 |
linprocfs_docpuinfo(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 162 |
struct uio *uio) |
|
| 169 | 163 |
{
|
| 170 | 164 |
char *ps; |
| 171 | 165 |
char psbuf[512]; /* XXX - conservative */ |
| ... | ... | |
| 262 | 256 |
} |
| 263 | 257 | |
| 264 | 258 |
int |
| 265 |
linprocfs_dostat(curp, p, pfs, uio) |
|
| 266 |
struct proc *curp; |
|
| 267 |
struct proc *p; |
|
| 268 |
struct pfsnode *pfs; |
|
| 269 |
struct uio *uio; |
|
| 259 |
linprocfs_dostat(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 260 |
struct uio *uio) |
|
| 270 | 261 |
{
|
| 271 | 262 |
char *ps; |
| 272 | 263 |
char psbuf[512]; |
| ... | ... | |
| 295 | 286 |
} |
| 296 | 287 | |
| 297 | 288 |
int |
| 298 |
linprocfs_douptime(curp, p, pfs, uio) |
|
| 299 |
struct proc *curp; |
|
| 300 |
struct proc *p; |
|
| 301 |
struct pfsnode *pfs; |
|
| 302 |
struct uio *uio; |
|
| 289 |
linprocfs_douptime(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 290 |
struct uio *uio) |
|
| 303 | 291 |
{
|
| 304 | 292 |
char *ps; |
| 305 | 293 |
char psbuf[64]; |
| ... | ... | |
| 314 | 302 |
} |
| 315 | 303 | |
| 316 | 304 |
int |
| 317 |
linprocfs_doversion(curp, p, pfs, uio) |
|
| 318 |
struct proc *curp; |
|
| 319 |
struct proc *p; |
|
| 320 |
struct pfsnode *pfs; |
|
| 321 |
struct uio *uio; |
|
| 305 |
linprocfs_doversion(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 306 |
struct uio *uio) |
|
| 322 | 307 |
{
|
| 323 | 308 |
char *ps; |
| 324 | 309 |
int xlen; |
| ... | ... | |
| 331 | 316 |
} |
| 332 | 317 | |
| 333 | 318 |
int |
| 334 |
linprocfs_doprocstat(curp, p, pfs, uio) |
|
| 335 |
struct proc *curp; |
|
| 336 |
struct proc *p; |
|
| 337 |
struct pfsnode *pfs; |
|
| 338 |
struct uio *uio; |
|
| 319 |
linprocfs_doprocstat(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 320 |
struct uio *uio) |
|
| 339 | 321 |
{
|
| 340 | 322 |
char *ps, psbuf[1024]; |
| 341 | 323 | |
| ... | ... | |
| 398 | 380 |
}; |
| 399 | 381 | |
| 400 | 382 |
int |
| 401 |
linprocfs_doprocstatus(curp, p, pfs, uio) |
|
| 402 |
struct proc *curp; |
|
| 403 |
struct proc *p; |
|
| 404 |
struct pfsnode *pfs; |
|
| 405 |
struct uio *uio; |
|
| 383 |
linprocfs_doprocstatus(struct proc *curp, struct proc *p, struct pfsnode *pfs, |
|
| 384 |
struct uio *uio) |
|
| 406 | 385 |
{
|
| 407 | 386 |
char *ps, psbuf[1024]; |
| 408 | 387 |
char *state; |
| linux/i386/linprocfs/linprocfs_subr.c 8 Dec 2005 22:42:37 -0000 | ||
|---|---|---|
| 85 | 85 |
* the vnode free list. |
| 86 | 86 |
*/ |
| 87 | 87 |
int |
| 88 |
linprocfs_allocvp(mp, vpp, pid, pfs_type) |
|
| 89 |
struct mount *mp; |
|
| 90 |
struct vnode **vpp; |
|
| 91 |
long pid; |
|
| 92 |
pfstype pfs_type; |
|
| 88 |
linprocfs_allocvp(struct mount *mp, struct vnode **vpp, long pid, |
|
| 89 |
pfstype pfs_type) |
|
| 93 | 90 |
{
|
| 94 | 91 |
struct thread *td = curthread; /* XXX */ |
| 95 | 92 |
struct pfsnode *pfs; |
| ... | ... | |
| 220 | 217 |
} |
| 221 | 218 | |
| 222 | 219 |
int |
| 223 |
linprocfs_freevp(vp) |
|
| 224 |
struct vnode *vp; |
|
| 220 |
linprocfs_freevp(struct vnode *vp) |
|
| 225 | 221 |
{
|
| 226 | 222 |
struct pfsnode **pfspp; |
| 227 | 223 |
struct pfsnode *pfs = VTOPFS(vp); |
| ... | ... | |
| 238 | 234 |
} |
| 239 | 235 | |
| 240 | 236 |
int |
| 241 |
linprocfs_rw(ap) |
|
| 242 |
struct vop_read_args *ap; |
|
| 237 |
linprocfs_rw(struct vop_read_args *ap) |
|
| 243 | 238 |
{
|
| 244 | 239 |
struct vnode *vp = ap->a_vp; |
| 245 | 240 |
struct uio *uio = ap->a_uio; |
| ... | ... | |
| 314 | 309 |
* EFAULT: user i/o buffer is not addressable |
| 315 | 310 |
*/ |
| 316 | 311 |
int |
| 317 |
vfs_getuserstr(uio, buf, buflenp) |
|
| 318 |
struct uio *uio; |
|
| 319 |
char *buf; |
|
| 320 |
int *buflenp; |
|
| 312 |
vfs_getuserstr(struct uio *uio, char *buf, int *buflenp) |
|
| 321 | 313 |
{
|
| 322 | 314 |
int xlen; |
| 323 | 315 |
int error; |
| ... | ... | |
| 349 | 341 |
} |
| 350 | 342 | |
| 351 | 343 |
vfs_namemap_t * |
| 352 |
vfs_findname(nm, buf, buflen) |
|
| 353 |
vfs_namemap_t *nm; |
|
| 354 |
char *buf; |
|
| 355 |
int buflen; |
|
| 344 |
vfs_findname(vfs_namemap_t *nm, char *buf, int buflen) |
|
| 356 | 345 |
{
|
| 357 | 346 | |
| 358 | 347 |
for (; nm->nm_name; nm++) |
| linux/i386/linprocfs/linprocfs_vfsops.c 8 Dec 2005 22:44:19 -0000 | ||
|---|---|---|
| 71 | 71 |
*/ |
| 72 | 72 |
/* ARGSUSED */ |
| 73 | 73 |
static int |
| 74 |
linprocfs_mount(mp, path, data, td) |
|
| 75 |
struct mount *mp; |
|
| 76 |
char *path; |
|
| 77 |
caddr_t data; |
|
| 78 |
struct thread *td; |
|
| 74 |
linprocfs_mount(struct mount *mp, char *path, caddr_t data, struct thread *td) |
|
| 79 | 75 |
{
|
| 80 | 76 |
size_t size; |
| 81 | 77 |
int error; |
| ... | ... | |
| 107 | 103 |
* unmount system call |
| 108 | 104 |
*/ |
| 109 | 105 |
static int |
| 110 |
linprocfs_unmount(mp, mntflags, td) |
|
| 111 |
struct mount *mp; |
|
| 112 |
int mntflags; |
|
| 113 |
struct thread *td; |
|
| 106 |
linprocfs_unmount(struct mount *mp, int mntflags, struct thread *td) |
|
| 114 | 107 |
{
|
| 115 | 108 |
int error; |
| 116 | 109 |
int flags = 0; |
| ... | ... | |
| 129 | 122 |
} |
| 130 | 123 | |
| 131 | 124 |
int |
| 132 |
linprocfs_root(mp, vpp) |
|
| 133 |
struct mount *mp; |
|
| 134 |
struct vnode **vpp; |
|
| 125 |
linprocfs_root(struct mount *mp, struct vnode **vpp) |
|
| 135 | 126 |
{
|
| 136 | 127 | |
| 137 | 128 |
return (linprocfs_allocvp(mp, vpp, 0, Proot)); |
| ... | ... | |
| 141 | 132 |
* Get file system statistics. |
| 142 | 133 |
*/ |
| 143 | 134 |
static int |
| 144 |
linprocfs_statfs(mp, sbp, td) |
|
| 145 |
struct mount *mp; |
|
| 146 |
struct statfs *sbp; |
|
| 147 |
struct thread *td; |
|
| 135 |
linprocfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td) |
|
| 148 | 136 |
{
|
| 149 | 137 |
sbp->f_bsize = PAGE_SIZE; |
| 150 | 138 |
sbp->f_iosize = PAGE_SIZE; |
| linux/i386/linprocfs/linprocfs_vnops.c 8 Dec 2005 22:47:52 -0000 | ||
|---|---|---|
| 124 | 124 |
* memory images. |
| 125 | 125 |
*/ |
| 126 | 126 |
static int |
| 127 |
linprocfs_open(ap) |
|
| 128 |
struct vop_open_args /* {
|
|
| 129 |
struct vnode *a_vp; |
|
| 130 |
int a_mode; |
|
| 131 |
struct ucred *a_cred; |
|
| 132 |
struct thread *a_td; |
|
| 133 |
} */ *ap; |
|
| 127 |
linprocfs_open(struct vop_open_args *ap) |
|
| 134 | 128 |
{
|
| 135 | 129 |
struct pfsnode *pfs = VTOPFS(ap->a_vp); |
| 136 | 130 |
struct proc *p2; |
| ... | ... | |
| 170 | 164 |
* any exclusive open flag (see _open above). |
| 171 | 165 |
*/ |
| 172 | 166 |
static int |
| 173 |
linprocfs_close(ap) |
|
| 174 |
struct vop_close_args /* {
|
|
| 175 |
struct vnode *a_vp; |
|
| 176 |
int a_fflag; |
|
| 177 |
struct ucred *a_cred; |
|
| 178 |
struct thread *a_td; |
|
| 179 |
} */ *ap; |
|
| 167 |
linprocfs_close(struct vop_close_args *ap) |
|
| 180 | 168 |
{
|
| 181 | 169 |
struct pfsnode *pfs = VTOPFS(ap->a_vp); |
| 182 | 170 |
struct proc *p; |
| ... | ... | |
| 214 | 202 |
* (vp) is not locked on entry or exit. |
| 215 | 203 |
*/ |
| 216 | 204 |
static int |
| 217 |
linprocfs_ioctl(ap) |
|
| 218 |
struct vop_ioctl_args *ap; |
|
| 205 |
linprocfs_ioctl(struct vop_ioctl_args *ap) |
|
| 219 | 206 |
{
|
| 220 | 207 |
struct pfsnode *pfs = VTOPFS(ap->a_vp); |
| 221 | 208 |
struct proc *procp; |
| ... | ... | |
| 307 | 294 |
* (EIO) would be a reasonable alternative. |
| 308 | 295 |
*/ |
| 309 | 296 |
static int |
| 310 |
linprocfs_bmap(ap) |
|
| 311 |
struct vop_bmap_args /* {
|
|
| 312 |
struct vnode *a_vp; |
|
| 313 |
daddr_t a_bn; |
|
| 314 |
struct vnode **a_vpp; |
|
| 315 |
daddr_t *a_bnp; |
|
| 316 |
int *a_runp; |
|
| 317 |
} */ *ap; |
|
| 297 |
linprocfs_bmap(struct vop_bmap_args *ap) |
|
| 318 | 298 |
{
|
| 319 | 299 | |
| 320 | 300 |
if (ap->a_vpp != NULL) |
| ... | ... | |
| 337 | 317 |
* on exit. |
| 338 | 318 |
*/ |
| 339 | 319 |
static int |
| 340 |
linprocfs_inactive(ap) |
|
| 341 |
struct vop_inactive_args /* {
|
|
| 342 |
struct vnode *a_vp; |
|
| 343 |
} */ *ap; |
|
| 320 |
linprocfs_inactive(struct vop_inactive_args *ap) |
|
| 344 | 321 |
{
|
| 345 | 322 |
/*struct vnode *vp = ap->a_vp;*/ |
| 346 | 323 | |
| ... | ... | |
| 355 | 332 |
* from any private lists. |
| 356 | 333 |
*/ |
| 357 | 334 |
static int |
| 358 |
linprocfs_reclaim(ap) |
|
| 359 |
struct vop_reclaim_args /* {
|
|
| 360 |
struct vnode *a_vp; |
|
| 361 |
} */ *ap; |
|
| 335 |
linprocfs_reclaim(struct vop_reclaim_args *ap) |
|
| 362 | 336 |
{
|
| 363 | 337 |
return (linprocfs_freevp(ap->a_vp)); |
| 364 | 338 |
} |
| ... | ... | |
| 369 | 343 |
* of (vp). |
| 370 | 344 |
*/ |
| 371 | 345 |
static int |
| 372 |
linprocfs_print(ap) |
|
| 373 |
struct vop_print_args /* {
|
|
| 374 |
struct vnode *a_vp; |
|
| 375 |
} */ *ap; |
|
| 346 |
linprocfs_print(struct vop_print_args *ap) |
|
| 376 | 347 |
{
|
| 377 | 348 |
struct pfsnode *pfs = VTOPFS(ap->a_vp); |
| 378 | 349 | |
| ... | ... | |
| 385 | 356 |
* generic entry point for unsupported operations |
| 386 | 357 |
*/ |
| 387 | 358 |
static int |
| 388 |
linprocfs_badop() |
|
| 359 |
linprocfs_badop(void)
|
|
| 389 | 360 |
{
|
| 390 | 361 | |
| 391 | 362 |
return (EIO); |
| ... | ... | |
| 401 | 372 |
* this is relatively minimal for procfs. |
| 402 | 373 |
*/ |
| 403 | 374 |
static int |
| 404 |
linprocfs_getattr(ap) |
|
| 405 |
struct vop_getattr_args /* {
|
|
| 406 |
struct vnode *a_vp; |
|
| 407 |
struct vattr *a_vap; |
|
| 408 |
struct ucred *a_cred; |
|
| 409 |
struct thread *a_td; |
|
| 410 |
} */ *ap; |
|
| 375 |
linprocfs_getattr(struct vop_getattr_args *ap) |
|
| 411 | 376 |
{
|
| 412 | 377 |
struct pfsnode *pfs = VTOPFS(ap->a_vp); |
| 413 | 378 |
struct vattr *vap = ap->a_vap; |
| ... | ... | |
| 547 | 512 |
} |
| 548 | 513 | |
| 549 | 514 |
static int |
| 550 |
linprocfs_setattr(ap) |
|
| 551 |
struct vop_setattr_args /* {
|
|
| 552 |
struct vnode *a_vp; |
|
| 553 |
struct vattr *a_vap; |
|
| 554 |
struct ucred *a_cred; |
|
| 555 |
struct thread *a_td; |
|
| 556 |
} */ *ap; |
|
| 515 |
linprocfs_setattr(struct vop_setattr_args *ap) |
|
| 557 | 516 |
{
|
| 558 | 517 | |
| 559 | 518 |
if (ap->a_vap->va_flags != VNOVAL) |
| ... | ... | |
| 585 | 544 |
* that the operation really does make sense. |
| 586 | 545 |
*/ |
| 587 | 546 |
static int |
| 588 |
linprocfs_access(ap) |
|
| 589 |
struct vop_access_args /* {
|
|
| 590 |
struct vnode *a_vp; |
|
| 591 |
int a_mode; |
|
| 592 |
struct ucred *a_cred; |
|
| 593 |
struct thread *a_td; |
|
| 594 |
} */ *ap; |
|
| 547 |
linprocfs_access(struct vop_access_args *ap) |
|
| 595 | 548 |
{
|
| 596 | 549 |
struct vattr *vap; |
| 597 | 550 |
struct vattr vattr; |
| ... | ... | |
| 639 | 592 |
* for most pseudo-filesystems very little needs to be done. |
| 640 | 593 |
*/ |
| 641 | 594 |
static int |
| 642 |
linprocfs_lookup(ap) |
|
| 643 |
struct vop_old_lookup_args /* {
|
|
| 644 |
struct vnode * a_dvp; |
|
| 645 |
struct vnode ** a_vpp; |
|
| 646 |
struct componentname * a_cnp; |
|
| 647 |
} */ *ap; |
|
| 595 |
linprocfs_lookup(struct vop_old_lookup_args *ap) |
|
| 648 | 596 |
{
|
| 649 | 597 |
struct componentname *cnp = ap->a_cnp; |
| 650 | 598 |
struct vnode **vpp = ap->a_vpp; |
| ... | ... | |
| 785 | 733 |
* Does this process have a text file? |
| 786 | 734 |
*/ |
| 787 | 735 |
int |
| 788 |
linprocfs_validfile(p) |
|
| 789 |
struct proc *p; |
|
| 736 |
linprocfs_validfile(struct proc *p) |
|
| 790 | 737 |
{
|
| 791 | 738 | |
| 792 | 739 |
return (procfs_findtextvp(p) != NULLVP); |
| ... | ... | |
| 1005 | 952 |
* readlink reads the link of `self' or `exe' |
| 1006 | 953 |
*/ |
| 1007 | 954 |
static int |
| 1008 |
linprocfs_readlink(ap) |
|
| 1009 |
struct vop_readlink_args *ap; |
|
| 955 |
linprocfs_readlink(struct vop_readlink_args *ap) |
|
| 1010 | 956 |
{
|
| 1011 | 957 |
char buf[16]; /* should be enough */ |
| 1012 | 958 |
struct proc *procp; |
| ... | ... | |
| 1051 | 997 |
* convert decimal ascii to pid_t |
| 1052 | 998 |
*/ |
| 1053 | 999 |
static pid_t |
| 1054 |
atopid(b, len) |
|
| 1055 |
const char *b; |
|
| 1056 |
u_int len; |
|
| 1000 |
atopid(const char *b, u_int len) |
|
| 1057 | 1001 |
{
|
| 1058 | 1002 |
pid_t p = 0; |
| 1059 | 1003 | |
| ... | ... | |
| 1101 | 1045 |
{ &vop_ioctl_desc, (void *) linprocfs_ioctl },
|
| 1102 | 1046 |
{ NULL, NULL }
|
| 1103 | 1047 |
}; |
| 1104 | ||
| ndis/kern_ndis.c 9 Dec 2005 07:16:00 -0000 | ||
|---|---|---|
| 195 | 195 |
*/ |
| 196 | 196 | |
| 197 | 197 |
static void |
| 198 |
ndis_runq(arg) |
|
| 199 |
void *arg; |
|
| 198 |
ndis_runq(void *arg) |
|
| 200 | 199 |
{
|
| 201 | 200 |
struct ndis_req *r = NULL, *die = NULL; |
| 202 | 201 |
struct ndisproc *p; |
| ... | ... | |
| 245 | 244 |
} |
| 246 | 245 | |
| 247 | 246 |
static int |
| 248 |
ndis_create_kthreads() |
|
| 247 |
ndis_create_kthreads(void)
|
|
| 249 | 248 |
{
|
| 250 | 249 |
struct ndis_req *r; |
| 251 | 250 |
int i, error = 0; |
| ... | ... | |
| 289 | 288 |
} |
| 290 | 289 | |
| 291 | 290 |
static void |
| 292 |
ndis_destroy_kthreads() |
|
| 291 |
ndis_destroy_kthreads(void)
|
|
| 293 | 292 |
{
|
| 294 | 293 |
struct ndis_req *r; |
| 295 | 294 | |
| ... | ... | |
| 311 | 310 |
} |
| 312 | 311 | |
| 313 | 312 |
static void |
| 314 |
ndis_stop_thread(t) |
|
| 315 |
int t; |
|
| 313 |
ndis_stop_thread(int t) |
|
| 316 | 314 |
{
|
| 317 | 315 |
struct ndis_req *r; |
| 318 | 316 |
struct ndisqhead *q; |
| ... | ... | |
| 357 | 355 |
} |
| 358 | 356 | |
| 359 | 357 |
static int |
| 360 |
ndis_enlarge_thrqueue(cnt) |
|
| 361 |
int cnt; |
|
| 358 |
ndis_enlarge_thrqueue(int cnt) |
|
| 362 | 359 |
{
|
| 363 | 360 |
struct ndis_req *r; |
| 364 | 361 |
int i; |
| ... | ... | |
| 376 | 373 |
} |
| 377 | 374 | |
| 378 | 375 |
static int |
| 379 |
ndis_shrink_thrqueue(cnt) |
|
| 380 |
int cnt; |
|
| 376 |
ndis_shrink_thrqueue(int cnt) |
|
| 381 | 377 |
{
|
| 382 | 378 |
struct ndis_req *r; |
| 383 | 379 |
int i; |
| ... | ... | |
| 400 | 396 |
} |
| 401 | 397 | |
| 402 | 398 |
int |
| 403 |
ndis_unsched(func, arg, t) |
|
| 404 |
void (*func)(void *); |
|
| 405 |
void *arg; |
|
| 406 |
int t; |
|
| 399 |
ndis_unsched(void (*func)(void *), void *arg, int t) |
|
| 407 | 400 |
{
|
| 408 | 401 |
struct ndis_req *r; |
| 409 | 402 |
struct ndisqhead *q; |
| ... | ... | |
| 434 | 427 |
} |
| 435 | 428 | |
| 436 | 429 |
int |
| 437 |
ndis_sched(func, arg, t) |
|
| 438 |
void (*func)(void *); |
|
| 439 |
void *arg; |
|
| 440 |
int t; |
|
| 430 |
ndis_sched(void (*func)(void *), void *arg, int t) |
|
| 441 | 431 |
{
|
| 442 | 432 |
struct ndis_req *r; |
| 443 | 433 |
struct ndisqhead *q; |
| ... | ... | |
| 494 | 484 |
} |
| 495 | 485 | |
| 496 | 486 |
int |
| 497 |
ndis_thsuspend(td, timo) |
|
| 498 |
thread_t td; |
|
| 499 |
int timo; |
|
| 487 |
ndis_thsuspend(thread_t td, int timo) |
|
| 500 | 488 |
{
|
| 501 | 489 |
int error; |
| 502 | 490 | |
| ... | ... | |
| 505 | 493 |
} |
| 506 | 494 | |
| 507 | 495 |
void |
| 508 |
ndis_thresume(td) |
|
| 509 |
struct thread *td; |
|
| 496 |
ndis_thresume(struct thread *td) |
|
| 510 | 497 |
{
|
| 511 | 498 |
wakeup(td); |
| 512 | 499 |
} |
| 513 | 500 | |
| 514 | 501 |
__stdcall static void |
| 515 |
ndis_sendrsrcavail_func(adapter) |
|
| 516 |
ndis_handle adapter; |
|
| 502 |
ndis_sendrsrcavail_func(ndis_handle adapter) |
|
| 517 | 503 |
{
|
| 518 | 504 |
return; |
| 519 | 505 |
} |
| 520 | 506 | |
| 521 | 507 |
__stdcall static void |
| 522 |
ndis_status_func(adapter, status, sbuf, slen) |
|
| 523 |
ndis_handle adapter; |
|
| 524 |
ndis_status status; |
|
| 525 |
void *sbuf; |
|
| 526 |
uint32_t slen; |
|
| 508 |
ndis_status_func(ndis_handle adapter, ndis_status status, void *sbuf, |
|
| 509 |
uint32_t slen) |
|
| 527 | 510 |
{
|
| 528 | 511 |
ndis_miniport_block *block; |
| 529 | 512 |
block = adapter; |
| ... | ... | |
| 534 | 517 |
} |
| 535 | 518 | |
| 536 | 519 |
__stdcall static void |
| 537 |
ndis_statusdone_func(adapter) |
|
| 538 |
ndis_handle adapter; |
|
| 520 |
ndis_statusdone_func(ndis_handle adapter) |
|
| 539 | 521 |
{
|
| 540 | 522 |
ndis_miniport_block *block; |
| 541 | 523 |
block = adapter; |
| ... | ... | |
| 546 | 528 |
} |
| 547 | 529 | |
| 548 | 530 |
__stdcall static void |
| 549 |
ndis_setdone_func(adapter, status) |
|
| 550 |
ndis_handle adapter; |
|
| 551 |
ndis_status status; |
|
| 531 |
ndis_setdone_func(ndis_handle adapter, ndis_status status) |
|
| 552 | 532 |
{
|
| 553 | 533 |
ndis_miniport_block *block; |
| 554 | 534 |
block = adapter; |
| ... | ... | |
| 559 | 539 |
} |
| 560 | 540 | |
| 561 | 541 |
__stdcall static void |
| 562 |
ndis_getdone_func(adapter, status) |
|
| 563 |
ndis_handle adapter; |
|
| 564 |
ndis_status status; |
|
| 542 |
ndis_getdone_func(ndis_handle adapter, ndis_status status) |
|
| 565 | 543 |
{
|
| 566 | 544 |
ndis_miniport_block *block; |
| 567 | 545 |
block = adapter; |
| ... | ... | |
| 572 | 550 |
} |
| 573 | 551 | |
| 574 | 552 |
__stdcall static void |
| 575 |
ndis_resetdone_func(adapter, status, addressingreset) |
|
| 576 |
ndis_handle adapter; |
|
| 577 |
ndis_status status; |
|
| 578 |
uint8_t addressingreset; |
|
| 553 |
ndis_resetdone_func(ndis_handle adapter, ndis_status status, |
|
| 554 |
uint8_t addressingreset) |
|
| 579 | 555 |
{
|
| 580 | 556 |
ndis_miniport_block *block; |
| 581 | 557 |
block = adapter; |
| ... | ... | |
| 587 | 563 |
} |
| 588 | 564 | |
| 589 | 565 |
int |
| 590 |
ndis_create_sysctls(arg) |
|
| 591 |
void *arg; |
|
| 566 |
ndis_create_sysctls(void *arg) |
|
| 592 | 567 |
{
|
| 593 | 568 |
struct ndis_softc *sc; |
| 594 | 569 |
ndis_cfg *vals; |
| ... | ... | |
| 672 | 647 |
} |
| 673 | 648 | |
| 674 | 649 |
int |
| 675 |
ndis_add_sysctl(arg, key, desc, val, flag) |
|
| 676 |
void *arg; |
|
| 677 |
char *key; |
|
| 678 |
char *desc; |
|
| 679 |
char *val; |
|
| 680 |
int flag; |
|
| 650 |
ndis_add_sysctl(void *arg, char *key, char *desc, char *val, int flag) |
|
| 681 | 651 |
{
|
| 682 | 652 |
struct ndis_softc *sc; |
| 683 | 653 |
struct ndis_cfglist *cfg; |
| ... | ... | |
| 713 | 683 |
} |
| 714 | 684 | |
| 715 | 685 |
int |
| 716 |
ndis_flush_sysctls(arg) |
|
| 717 |
void *arg; |
|
| 686 |
ndis_flush_sysctls(void *arg) |
|
| 718 | 687 |
{
|
| 719 | 688 |
struct ndis_softc *sc; |
| 720 | 689 |
struct ndis_cfglist *cfg; |
| ... | ... | |
| 733 | 702 |
} |
| 734 | 703 | |
| 735 | 704 |
static void |
| 736 |
ndis_return(arg) |
|
| 737 |
void *arg; |
|
| 705 |
ndis_return(void *arg) |
|
| 738 | 706 |
{
|
| 739 | 707 |
struct ndis_softc *sc; |
| 740 | 708 |
ndis_return_handler returnfunc; |
| ... | ... | |
| 792 | 760 |
} |
| 793 | 761 | |
| 794 | 762 |
void |
| 795 |
ndis_free_bufs(b0) |
|
| 796 |
ndis_buffer *b0; |
|
| 763 |
ndis_free_bufs(ndis_buffer *b0) |
|
| 797 | 764 |
{
|
| 798 | 765 |
ndis_buffer *next; |
| 799 | 766 | |
| ... | ... | |
| 810 | 777 |
} |
| 811 | 778 | |
| 812 | 779 |
void |
| 813 |
ndis_free_packet(p) |
|
| 814 |
ndis_packet *p; |
|
| 780 |
ndis_free_packet(ndis_packet *p) |
|
| 815 | 781 |
{
|
| 816 | 782 |
if (p == NULL) |
| 817 | 783 |
return; |
| ... | ... | |
| 823 | 789 |
} |
| 824 | 790 | |
| 825 | 791 |
int |
| 826 |
ndis_convert_res(arg) |
|
| 827 |
void *arg; |
|
| 792 |
ndis_convert_res(void *arg) |
|
| 828 | 793 |
{
|
| 829 | 794 |
struct ndis_softc *sc; |
| 830 | 795 |
ndis_resource_list *rl = NULL; |
| ... | ... | |
| 947 | 912 |
*/ |
| 948 | 913 | |
| 949 | 914 |
int |
| 950 |
ndis_ptom(m0, p) |
|
| 951 |
struct mbuf **m0; |
|
| 952 |
ndis_packet *p; |
|
| 915 |
ndis_ptom(struct mbuf **m0, ndis_packet *p) |
|
| 953 | 916 |
{
|
| 954 | 917 |
struct mbuf *m, *prev = NULL; |
| 955 | 918 |
ndis_buffer *buf; |
| ... | ... | |
| 1015 | 978 |
*/ |
| 1016 | 979 | |
| 1017 | 980 |
int |
| 1018 |
ndis_mtop(m0, p) |
|
| 1019 |
struct mbuf *m0; |
|
| 1020 |
ndis_packet **p; |
|
| 981 |
ndis_mtop(struct mbuf *m0, ndis_packet **p) |
|
| 1021 | 982 |
{
|
| 1022 | 983 |
struct mbuf *m; |
| 1023 | 984 |
ndis_buffer *buf = NULL, *prev = NULL; |
| ... | ... | |
| 1063 | 1024 |
} |
| 1064 | 1025 | |
| 1065 | 1026 |
int |
| 1066 |
ndis_get_supported_oids(arg, oids, oidcnt) |
|
| 1067 |
void *arg; |
|
| 1068 |
ndis_oid **oids; |
|
| 1069 |
int *oidcnt; |
|
| 1027 |
ndis_get_supported_oids(void *arg, ndis_oid **oids, int *oidcnt) |
|
| 1070 | 1028 |
{
|
| 1071 | 1029 |
int len, rval; |
| 1072 | 1030 |
ndis_oid *o; |
| ... | ... | |
| 1092 | 1050 |
} |
| 1093 | 1051 | |
| 1094 | 1052 |
int |
| 1095 |
ndis_set_info(arg, oid, buf, buflen) |
|
| 1096 |
void *arg; |
|
| 1097 |
ndis_oid oid; |
|
| 1098 |
void *buf; |
|
| 1099 |
int *buflen; |
|
| 1053 |
ndis_set_info(void *arg, ndis_oid oid, void *buf, int *buflen) |
|
| 1100 | 1054 |
{
|
| 1101 | 1055 |
struct ndis_softc *sc; |
| 1102 | 1056 |
ndis_status rval; |
| ... | ... | |
| 1151 | 1105 |
typedef __stdcall void (*ndis_senddone_func)(ndis_handle, ndis_packet *, ndis_status); |
| 1152 | 1106 | |
| 1153 | 1107 |
int |
| 1154 |
ndis_send_packets(arg, packets, cnt) |
|
| 1155 |
void *arg; |
|
| 1156 |
ndis_packet **packets; |
|
| 1157 |
int cnt; |
|
| 1108 |
ndis_send_packets(void *arg, ndis_packet **packets, int cnt) |
|
| 1158 | 1109 |
{
|
| 1159 | 1110 |
struct ndis_softc *sc; |
| 1160 | 1111 |
ndis_handle adapter; |
| ... | ... | |
| 1191 | 1142 |
} |
| 1192 | 1143 | |
| 1193 | 1144 |
int |
| 1194 |
ndis_send_packet(arg, packet) |
|
| 1195 |
void *arg; |
|
| 1196 |
ndis_packet *packet; |
|
| 1145 |
ndis_send_packet(void *arg, ndis_packet *packet) |
|
| 1197 | 1146 |
{
|
| 1198 | 1147 |
struct ndis_softc *sc; |
| 1199 | 1148 |
ndis_handle adapter; |
| ... | ... | |
| 1222 | 1171 |
} |
| 1223 | 1172 | |
| 1224 | 1173 |
int |
| 1225 |
ndis_init_dma(arg) |
|
| 1226 |
void *arg; |
|
| 1174 |
ndis_init_dma(void *arg) |
|
| 1227 | 1175 |
{
|
| 1228 | 1176 |
struct ndis_softc *sc; |
| 1229 | 1177 |
int i, error; |
| ... | ... | |
| 1246 | 1194 |
} |
| 1247 | 1195 | |
| 1248 | 1196 |
int |
| 1249 |
ndis_destroy_dma(arg) |
|
| 1250 |
void *arg; |
|
| 1197 |
ndis_destroy_dma(void *arg) |
|
| 1251 | 1198 |
{
|
| 1252 | 1199 |
struct ndis_softc *sc; |
| 1253 | 1200 |
struct mbuf *m; |
| ... | ... | |
| 1274 | 1221 |
} |
| 1275 | 1222 | |
| 1276 | 1223 |
int |
| 1277 |
ndis_reset_nic(arg) |
|
| 1278 |
void *arg; |
|
| 1224 |
ndis_reset_nic(void *arg) |
|
| 1279 | 1225 |
{
|
| 1280 | 1226 |
struct ndis_softc *sc; |
| 1281 | 1227 |
ndis_handle adapter; |
| ... | ... | |
| 1307 | 1253 |
} |
| 1308 | 1254 | |
| 1309 | 1255 |
int |
| 1310 |
ndis_halt_nic(arg) |
|
| 1311 |
void *arg; |
|
| 1256 |
ndis_halt_nic(void *arg) |
|
| 1312 | 1257 |
{
|
| 1313 | 1258 |
struct ndis_softc *sc; |
| 1314 | 1259 |
ndis_handle adapter; |
| ... | ... | |
| 1345 | 1290 |
} |
| 1346 | 1291 | |
| 1347 | 1292 |
int |
| 1348 |
ndis_shutdown_nic(arg) |
|
| 1349 |
void *arg; |
|
| 1293 |
ndis_shutdown_nic(void *arg) |
|
| 1350 | 1294 |
{
|
| 1351 | 1295 |
struct ndis_softc *sc; |
| 1352 | 1296 |
ndis_handle adapter; |
| ... | ... | |
| 1373 | 1317 |
} |
| 1374 | 1318 | |
| 1375 | 1319 |
int |
| 1376 |
ndis_init_nic(arg) |
|
| 1377 |
void *arg; |
|
| 1320 |
ndis_init_nic(void *arg) |
|
| 1378 | 1321 |
{
|
| 1379 | 1322 |
struct ndis_softc *sc; |
| 1380 | 1323 |
ndis_miniport_block *block; |
| ... | ... | |
| 1417 | 1360 |
} |
| 1418 | 1361 | |
| 1419 | 1362 |
void |
| 1420 |
ndis_enable_intr(arg) |
|
| 1421 |
void *arg; |
|
| 1363 |
ndis_enable_intr(void *arg) |
|
| 1422 | 1364 |
{
|
| 1423 | 1365 |
struct ndis_softc *sc; |
| 1424 | 1366 |
ndis_handle adapter; |
| ... | ... | |
| 1435 | 1377 |
} |
| 1436 | 1378 | |
| 1437 | 1379 |
void |
| 1438 |
ndis_disable_intr(arg) |
|
| 1439 |
void *arg; |
|
| 1380 |
ndis_disable_intr(void *arg) |
|
| 1440 | 1381 |
{
|
| 1441 | 1382 |
struct ndis_softc *sc; |
| 1442 | 1383 |
ndis_handle adapter; |
| ... | ... | |
| 1456 | 1397 |
} |
| 1457 | 1398 | |
| 1458 | 1399 |
int |
| 1459 |
ndis_isr(arg, ourintr, callhandler) |
|
| 1460 |
void *arg; |
|
| 1461 |
int *ourintr; |
|
| 1462 |
int *callhandler; |
|
| 1400 |
ndis_isr(void *arg, int *ourintr, int *callhandler) |
|
| 1463 | 1401 |
{
|
| 1464 | 1402 |
struct ndis_softc *sc; |
| 1465 | 1403 |
ndis_handle adapter; |
| ... | ... | |
| 1483 | 1421 |
} |
| 1484 | 1422 | |
| 1485 | 1423 |
int |
| 1486 |
ndis_intrhand(arg) |
|
| 1487 |
void *arg; |
|
| 1424 |
ndis_intrhand(void *arg) |
|
| 1488 | 1425 |
{
|
| 1489 | 1426 |
struct ndis_softc *sc; |
| 1490 | 1427 |
ndis_handle adapter; |
| ... | ... | |
| 1508 | 1445 |
} |
| 1509 | 1446 | |
| 1510 | 1447 |
int |
| 1511 |
ndis_get_info(arg, oid, buf, buflen) |
|
| 1512 |
void *arg; |
|
| 1513 |
ndis_oid oid; |
|
| 1514 |
void *buf; |
|
| 1515 |
int *buflen; |
|
| 1448 |
ndis_get_info(void *arg, ndis_oid oid, void *buf, int *buflen) |
|
| 1516 | 1449 |
{
|
| 1517 | 1450 |
struct ndis_softc *sc; |
| 1518 | 1451 |
ndis_status rval; |
| ... | ... | |
| 1568 | 1501 |
} |
| 1569 | 1502 | |
| 1570 | 1503 |
int |
| 1571 |
ndis_unload_driver(arg) |
|
| 1572 |
void *arg; |
|
| 1504 |
ndis_unload_driver(void *arg) |
|
| 1573 | 1505 |
{
|
| 1574 | 1506 |
struct ndis_softc *sc; |
| 1575 | 1507 | |
| ... | ... | |
| 1588 | 1520 |
#define NDIS_LOADED htonl(0x42534F44) |
| 1589 | 1521 | |
| 1590 | 1522 |
int |
| 1591 |
ndis_load_driver(img, arg) |
|
| 1592 |
vm_offset_t img; |
|
| 1593 |
void *arg; |
|
| 1523 |
ndis_load_driver(vm_offset_t img, void *arg) |
|
| 1594 | 1524 |
{
|
| 1595 | 1525 |
driver_entry entry; |
| 1596 | 1526 |
image_optional_header opt_hdr; |
| ndis/subr_hal.c 9 Dec 2005 06:42:56 -0000 | ||
|---|---|---|
| 86 | 86 |
extern struct mtx_pool *ndis_mtxpool; |
| 87 | 87 | |
| 88 | 88 |
__stdcall static void |
| 89 |
hal_stall_exec_cpu(usecs) |
|
| 90 |
uint32_t usecs; |
|
| 89 |
hal_stall_exec_cpu(uint32_t usecs) |
|
| 91 | 90 |
{
|
| 92 | 91 |
DELAY(usecs); |
| 93 | 92 |
return; |
| 94 | 93 |
} |
| 95 | 94 | |
| 96 | 95 |
__stdcall static void |
| 97 |
hal_writeport_ulong(port, val) |
|
| 98 |
uint32_t *port; |
|
| 99 |
uint32_t val; |
|
| 96 |
hal_writeport_ulong(uint32_t *port, uint32_t val) |
|
| 100 | 97 |
{
|
| 101 | 98 |
bus_space_write_4(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port, val); |
| 102 | 99 |
return; |
| 103 | 100 |
} |
| 104 | 101 | |
| 105 | 102 |
__stdcall static void |
| 106 |
hal_writeport_ushort(port, val) |
|
| 107 |
uint16_t *port; |
|
| 108 |
uint16_t val; |
|
| 103 |
hal_writeport_ushort(uint16_t *port, uint16_t val) |
|
| 109 | 104 |
{
|
| 110 | 105 |
bus_space_write_2(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port, val); |
| 111 | 106 |
return; |
| 112 | 107 |
} |
| 113 | 108 | |
| 114 | 109 |
__stdcall static void |
| 115 |
hal_writeport_uchar(port, val) |
|
| 116 |
uint8_t *port; |
|
| 117 |
uint8_t val; |
|
| 110 |
hal_writeport_uchar(uint8_t *port, uint8_t val) |
|
| 118 | 111 |
{
|
| 119 | 112 |
bus_space_write_1(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port, val); |
| 120 | 113 |
return; |
| 121 | 114 |
} |
| 122 | 115 | |
| 123 | 116 |
__stdcall static void |
| 124 |
hal_writeport_buf_ulong(port, val, cnt) |
|
| 125 |
uint32_t *port; |
|
| 126 |
uint32_t *val; |
|
| 127 |
uint32_t cnt; |
|
| 117 |
hal_writeport_buf_ulong(uint32_t *port, uint32_t *val, uint32_t cnt) |
|
| 128 | 118 |
{
|
| 129 | 119 |
bus_space_write_multi_4(NDIS_BUS_SPACE_IO, 0x0, |
| 130 | 120 |
(bus_size_t)port, val, cnt); |
| ... | ... | |
| 132 | 122 |
} |
| 133 | 123 | |
| 134 | 124 |
__stdcall static void |
| 135 |
hal_writeport_buf_ushort(port, val, cnt) |
|
| 136 |
uint16_t *port; |
|
| 137 |
uint16_t *val; |
|
| 138 |
uint32_t cnt; |
|
| 125 |
hal_writeport_buf_ushort(uint16_t *port, uint16_t *val, uint32_t cnt) |
|
| 139 | 126 |
{
|
| 140 | 127 |
bus_space_write_multi_2(NDIS_BUS_SPACE_IO, 0x0, |
| 141 | 128 |
(bus_size_t)port, val, cnt); |
| ... | ... | |
| 143 | 130 |
} |
| 144 | 131 | |
| 145 | 132 |
__stdcall static void |
| 146 |
hal_writeport_buf_uchar(port, val, cnt) |
|
| 147 |
uint8_t *port; |
|
| 148 |
uint8_t *val; |
|
| 149 |
uint32_t cnt; |
|
| 133 |
hal_writeport_buf_uchar(uint8_t *port, uint8_t *val, uint32_t cnt) |
|
| 150 | 134 |
{
|
| 151 | 135 |
bus_space_write_multi_1(NDIS_BUS_SPACE_IO, 0x0, |
| 152 | 136 |
(bus_size_t)port, val, cnt); |
| ... | ... | |
| 154 | 138 |
} |
| 155 | 139 | |
| 156 | 140 |
__stdcall static uint16_t |
| 157 |
hal_readport_ushort(port) |
|
| 158 |
uint16_t *port; |
|
| 141 |
hal_readport_ushort(uint16_t *port) |
|
| 159 | 142 |
{
|
| 160 | 143 |
return(bus_space_read_2(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port)); |
| 161 | 144 |
} |
| 162 | 145 | |
| 163 | 146 |
__stdcall static uint32_t |
| 164 |
hal_readport_ulong(port) |
|
| 165 |
uint32_t *port; |
|
| 147 |
hal_readport_ulong(uint32_t *port) |
|
| 166 | 148 |
{
|
| 167 | 149 |
return(bus_space_read_4(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port)); |
| 168 | 150 |
} |
| 169 | 151 | |
| 170 | 152 |
__stdcall static uint8_t |
| 171 |
hal_readport_uchar(port) |
|
| 172 |
uint8_t *port; |
|
| 153 |
hal_readport_uchar(uint8_t *port) |
|
| 173 | 154 |
{
|
| 174 | 155 |
return(bus_space_read_1(NDIS_BUS_SPACE_IO, 0x0, (bus_size_t)port)); |
| 175 | 156 |
} |
| 176 | 157 | |
| 177 | 158 |
__stdcall static void |
| 178 |
hal_readport_buf_ulong(port, val, cnt) |
|
| 179 |
uint32_t *port; |
|
| 180 |
uint32_t *val; |
|
| 181 |
uint32_t cnt; |
|
| 159 |
hal_readport_buf_ulong(uint32_t *port, uint32_t *val, uint32_t cnt) |
|
| 182 | 160 |
{
|
| 183 | 161 |
bus_space_read_multi_4(NDIS_BUS_SPACE_IO, 0x0, |
| 184 | 162 |
(bus_size_t)port, val, cnt); |
| ... | ... | |
| 186 | 164 |
} |
| 187 | 165 | |
| 188 | 166 |
__stdcall static void |
| 189 |
hal_readport_buf_ushort(port, val, cnt) |
|
| 190 |
uint16_t *port; |
|
| 191 |
uint16_t *val; |
|
| 192 |
uint32_t cnt; |
|
| 167 |
hal_readport_buf_ushort(uint16_t *port, uint16_t *val, uint32_t cnt) |
|
| 193 | 168 |
{
|
| 194 | 169 |
bus_space_read_multi_2(NDIS_BUS_SPACE_IO, 0x0, |
| 195 | 170 |
(bus_size_t)port, val, cnt); |
| ... | ... | |
| 197 | 172 |
} |
| 198 | 173 | |
| 199 | 174 |
__stdcall static void |
| 200 |
hal_readport_buf_uchar(port, val, cnt) |
|
| 201 |
uint8_t *port; |
|
| 202 |
uint8_t *val; |
|
| 203 |
uint32_t cnt; |
|
| 175 |
hal_readport_buf_uchar(uint8_t *port, uint8_t *val, uint32_t cnt) |
|
| 204 | 176 |
{
|
| 205 | 177 |
bus_space_read_multi_1(NDIS_BUS_SPACE_IO, 0x0, |
| 206 | 178 |
(bus_size_t)port, val, cnt); |
| ... | ... | |
| 287 | 259 |
} |
| 288 | 260 | |
| 289 | 261 |
__stdcall static uint64_t |
| 290 |
hal_perfcount(freq) |
|
| 291 |
uint64_t *freq; |
|
| 262 |
hal_perfcount(uint64_t *freq) |
|
| 292 | 263 |
{
|
| 293 | 264 |
if (freq != NULL) |
| 294 | 265 |
*freq = hz; |
| ... | ... | |
| 326 | 297 |
} |
| 327 | 298 | |
| 328 | 299 |
__stdcall |
| 329 |
static void dummy() |
|
| 300 |
static void dummy(void)
|
|
| 330 | 301 |
{
|
| 331 | 302 |
printf ("hal dummy called...\n");
|
| 332 | 303 |
return; |
| ndis/subr_ndis.c 9 Dec 2005 00:17:22 -0000 | ||
|---|---|---|
| 293 | 293 |
#define NDIS_POOL_EXTRA 16 |
| 294 | 294 | |
| 295 | 295 |
int |
| 296 |
ndis_libinit() |
|
| 296 |
ndis_libinit(void)
|
|
| 297 | 297 |
{
|
| 298 | 298 |
strcpy(ndis_filepath, "/compat/ndis"); |
| 299 | 299 |
return(0); |
| 300 | 300 |
} |
| 301 | 301 | |
| 302 | 302 |
int |
| 303 |
ndis_libfini() |
|
| 303 |
ndis_libfini(void)
|
|
| 304 | 304 |
{
|
| 305 | 305 |
return(0); |
| 306 | 306 |
} |
| ... | ... | |
| 313 | 313 |
*/ |
| 314 | 314 | |
| 315 | 315 |
int |
| 316 |
ndis_ascii_to_unicode(ascii, unicode) |
|
| 317 |
char *ascii; |
|
| 318 |
uint16_t **unicode; |
|
| 316 |
ndis_ascii_to_unicode(char *ascii, uint16_t **unicode) |
|
| 319 | 317 |
{
|
| 320 | 318 |
uint16_t *ustr; |
| 321 | 319 |
int i; |