/* Get file details for a specified NFS File */ void nfsfs_stat(pid_t pid, VNode self, const char *path, stat_t *buf) { dprintf(1, "*** nfsfs_stat: %p, %s, %p\n", self, path, buf); Process *p = process_lookup(pid); if (self != NULL) { NFS_File *nf = (NFS_File *) self->extra; if (nf == NULL) { dprintf(0, "!!! nfsfs_stat: Broken NFS file! No nfs struct! (file %s)\n", path); syscall_reply(process_get_tid(p), SOS_VFS_ERROR); return; } memcpy((void *) buf, (void *) &(self->vstat), sizeof(stat_t)); syscall_reply(process_get_tid(p), SOS_VFS_OK); } // stat non open file else { dprintf(1, "*** nfsfs_stat: trying to stat non open file! (file %s)\n", path); NFS_StatRequest *rq = (NFS_StatRequest *) create_request(RT_STAT, self, pid); rq->stat = buf; rq->path = path; check_request((NFS_BaseRequest *) rq); } }
/* NFS Callback for NFS_getdirent */ static void getdirent_cb(uintptr_t token, int status, int num_entries, struct nfs_filename *filenames, int next_cookie) { dprintf(1, "*** nfsfs_dirent_cb: %d, %d, %d, %d\n", token, status, num_entries, next_cookie); NFS_DirRequest *rq = (NFS_DirRequest *) get_request(token); if (rq == NULL) { dprintf(0, "!!! nfsfs: Corrupt dirent callback, no matching token: %d\n", token); return; } Process *p = process_lookup(rq->p.pid); if (status != NFS_OK) { syscall_reply(process_get_tid(p), status_nfs2vfs(status)); remove_request((NFS_BaseRequest *) rq); return; } // got it if (rq->cpos + num_entries >= rq->pos + 1) { dprintf(2, "found file, getting now\n"); int status = SOS_VFS_ERROR; struct nfs_filename *nfile = &filenames[rq->pos - rq->cpos]; if (nfile->size + 1 <= rq->nbyte) { memcpy(rq->buf, nfile->file, nfile->size); rq->buf[nfile->size] = '\0'; status = nfile->size; } else { dprintf(0, "!!! nfs_getdirent_cb: Filename too big for given buffer! (%d) (%d)\n", nfile->size, rq->nbyte); status = SOS_VFS_NOMEM; } syscall_reply(process_get_tid(p), status); remove_request((NFS_BaseRequest *) rq); } // need later directory entry else if (next_cookie > 0) { dprintf(2, "Need more dir entries to get file\n"); rq->cpos += num_entries; nfs_readdir(&nfs_mnt, next_cookie, IO_MAX_BUFFER, getdirent_cb, rq->p.token); } // error case, just return SOS_VFS_OK to say nothing read, its not an error just eof else { dprintf(2, "nfsfs_getdirent: didnt find file (%d)\n", rq->pos); syscall_reply(process_get_tid(p), SOS_VFS_EOF); remove_request((NFS_BaseRequest *) rq); } }
/* Remove a file */ void nfsfs_remove(pid_t pid, VNode self, const char *path) { dprintf(1, "*** nfsfs_remove: %d %s ***\n", pid, path); if (self != NULL) { // cant remove open files syscall_reply(process_get_tid(process_lookup(pid)), SOS_VFS_OPEN); } else { // remove file NFS_RemoveRequest *rq = (NFS_RemoveRequest *) create_request(RT_REMOVE, self, pid); rq->path = path; check_request((NFS_BaseRequest *) rq); } }
/* NFS Callback for NFS_Remove */ static void remove_cb(uintptr_t token, int status) { dprintf(1, "*** nfsfs: remove_cb %u %d *** \n", token, status); NFS_RemoveRequest *rq = (NFS_RemoveRequest *) get_request(token); if (rq == NULL) { dprintf(0, "!!! nfsfs: Corrupt remove callback, no matching token: %d\n", token); return; } syscall_reply(process_get_tid(process_lookup(rq->p.pid)), status_nfs2vfs(status)); remove_request((NFS_BaseRequest *) rq); }
gfarm_error_t process_does_match(gfarm_pid_t pid, gfarm_int32_t keytype, size_t keylen, char *sharedkey, struct process **processp) { struct process *process = process_lookup((gfarm_int32_t)pid); if (process == NULL) return (GFARM_ERR_NO_SUCH_PROCESS); if (keytype != GFM_PROTO_PROCESS_KEY_TYPE_SHAREDSECRET || keylen != GFM_PROTO_PROCESS_KEY_LEN_SHAREDSECRET || memcmp(sharedkey, process->sharedkey, GFM_PROTO_PROCESS_KEY_LEN_SHAREDSECRET) != 0) return (GFARM_ERR_AUTHENTICATION); *processp = process; return (GFARM_ERR_NO_ERROR); }
void tcp_inspect(struct ip *iph, struct tcphdr *tcp) { if (tcp->th_flags == TH_SYN) { struct pfl0w_process *p = malloc (sizeof *p); fprintf(stderr, "TCP [%d] (%s:%d - ", tcp->th_flags, inet_ntoa(iph->ip_src), ntohs(tcp->th_sport)); fprintf(stderr, "%s:%d)\n", inet_ntoa(iph->ip_dst), ntohs(tcp->th_dport)); p->src = iph->ip_src.s_addr; p->dst = iph->ip_dst.s_addr; p->src_port = ntohs(tcp->th_sport); p->dst_port = ntohs(tcp->th_dport); int r = process_lookup(p); fprintf(stderr, "Process pid: %d\n", r); free(p); } }
/* NFS Callback for NFS_Stat */ static void stat_cb(uintptr_t token, int status, struct cookie *fh, fattr_t *attr) { dprintf(1, "*** nfsfs_stat_cb: %d, %d, %p, %p\n", token, status, fh, attr); NFS_StatRequest *rq = (NFS_StatRequest *) get_request(token); if (rq == NULL) { dprintf(0, "!!! nfsfs: Corrupt stat callback, no matching token: %d\n", token); return; } if (status == NFS_OK) { cp_stats(rq->stat, attr); } syscall_reply(process_get_tid(process_lookup(rq->p.pid)), status_nfs2vfs(status)); remove_request((NFS_BaseRequest *) rq); }
int sys_getsid(struct thread *td, struct sys_getsid_args *ap) { struct process *p; mutex_slock(&processtopo); if (ap->pid == 0) { p = td->td_process; } else { p = process_lookup(ap->pid); if (p == NULL) { mutex_sunlock(&processtopo); return (ESRCH); } } ap->retval = p->p_group->pg_session->s_id; mutex_sunlock(&processtopo); return (0); }
int32_t waitpid(int32_t pid, int32_t *wstatus, int32_t options) { struct process_control_block_type *proc; proc=process_lookup(pid); if (debug) printk("Waiting on pid %d\n",pid); while (proc->status!=PROCESS_STATUS_EXITED) { schedule(); } if (wstatus!=NULL) *wstatus=proc->exit_value; /* Kill the zombie now? */ /* Reschedule? */ return pid; }
/* Flush the given nfs file to disk. (UNSUPPORTED) (no buffering used) */ void nfsfs_flush(pid_t pid, VNode self, fildes_t file) { dprintf(1, "*** nfsfs_flush: %d, %p, %d\n", pid, self, file); dprintf(1, "!!! nfsfs_flush: Not implemented for nfs fs\n"); syscall_reply(process_get_tid(process_lookup(pid)), SOS_VFS_NOTIMP); }