/* This file contains the procedures for creating, opening, closing, and * seeking on files. * * The entry points into this file are * do_creat: perform the CREAT system call * do_open: perform the OPEN system call * do_mknod: perform the MKNOD system call * do_mkdir: perform the MKDIR system call * do_close: perform the CLOSE system call * do_lseek: perform the LSEEK system call * * Changes for VFS: * Jul 2006 (Balazs Gerofi) */ #include "fs.h" #include #include #include #include #include #include #include #include "file.h" #include "fproc.h" #include "lock.h" #include "param.h" #include #include #include #include "vnode.h" #include "vmnt.h" #define offset_lo m2_l1 #define offset_high m2_l2 FORWARD _PROTOTYPE( int common_open, (int oflags, mode_t omode) ); FORWARD _PROTOTYPE( int create_open, (_mnx_Mode_t omode, int excl, struct vnode **vpp, int *created) ); FORWARD _PROTOTYPE( int exists_open, (struct vnode *vp, _mnx_Mode_t bits, int oflags)); FORWARD _PROTOTYPE( int pipe_open, (struct vnode *vp,mode_t bits,int oflags)); /*===========================================================================* * do_creat * *===========================================================================*/ PUBLIC int do_creat() { /* Perform the creat(name, mode) system call. */ int r; if (fetch_name(m_in.name, m_in.name_length, M3) != OK) return(err_code); r = common_open(O_WRONLY | O_CREAT | O_TRUNC, (mode_t) m_in.mode); return(r); } /*===========================================================================* * do_open * *===========================================================================*/ PUBLIC int do_open() { /* Perform the open(name, flags,...) system call. */ int create_mode = 0; /* is really mode_t but this gives problems */ int r; /* If O_CREAT is set, open has three parameters, otherwise two. */ if (m_in.mode & O_CREAT) { create_mode = m_in.c_mode; r = fetch_name(m_in.c_name, m_in.name1_length, M1); } else { r = fetch_name(m_in.name, m_in.name_length, M3); } if (r != OK) { return(err_code); /* name was bad */ } r = common_open(m_in.mode, create_mode); return(r); } /*===========================================================================* * common_open * *===========================================================================*/ PRIVATE int common_open(register int oflags, mode_t omode) { /* Common code from do_creat and do_open. */ int b, m, r, created, found; mode_t bits; struct filp *fil_ptr, *filp2; struct vnode *vp; struct vmnt *vmp; struct dmap *dp; /* Remap the bottom two bits of oflags. */ m = oflags & O_ACCMODE; switch(m) { case O_RDONLY: bits = R_BIT; break; case O_WRONLY: bits = W_BIT; break; case O_RDWR: bits = R_BIT | W_BIT; break; default: return EINVAL; } /* See if file descriptor and filp slots are available. */ if ((r = get_fd(0, bits, &m_in.fd, &fil_ptr)) != OK) return(r); /* If O_CREATE, set umask */ if (oflags & O_CREAT) { omode = I_REGULAR | (omode & ALL_MODES & fp->fp_umask); } if (oflags & O_CREAT) r= create_open(omode, !!(oflags & O_EXCL), &vp, &created); else { #if 0 printf("vfs:common_open: path '%s'\n", user_fullpath); #endif created= FALSE; r= lookup_vp(0 /*flags*/, 0 /*!use_realuid*/, &vp); } if (r != OK) return r; if (!created) { r= exists_open(vp, bits, oflags); if (r != OK) { put_vnode(vp); return r; } } /* Claim the file descriptor and filp slot and fill them in. */ fp->fp_filp[m_in.fd] = fil_ptr; FD_SET(m_in.fd, &fp->fp_filp_inuse); fil_ptr->filp_count = 1; fil_ptr->filp_flags = oflags; fil_ptr->filp_vno = vp; switch (vp->v_mode & I_TYPE) { case I_CHAR_SPECIAL: /* Invoke the driver for special processing. */ r = dev_open(vp->v_sdev, who_e, bits | (oflags & ~O_ACCMODE)); if (r == SUSPEND) suspend(FP_BLOCKED_ON_DOPEN); /* suspend caller */ break; case I_BLOCK_SPECIAL: /* Invoke the driver for special processing. */ r = dev_open(vp->v_sdev, who_e, bits | (oflags & ~O_ACCMODE)); if (r != OK) break; /* Check whether the device is mounted or not */ found = 0; for (vmp = &vmnt[0]; vmp < &vmnt[NR_MNTS]; ++vmp) { if (vmp->m_dev == vp->v_sdev) { found = 1; break; } } /* Who is going to be responsible for this device? */ if (found) { vp->v_bfs_e = vmp->m_fs_e; } else { /* To be handled in the root FS proc if not mounted */ vp->v_bfs_e = ROOT_FS_E; } /* Get the driver endpoint of the block spec device */ dp = &dmap[(vp->v_sdev >> MAJOR) & BYTE]; if (dp->dmap_driver == NONE) { printf("VFSblock_spec_open: driver not found for device %d\n", vp->v_sdev); r = EINVAL; break; } /* Send the driver endpoint (even if it is known already...) */ if ((r = req_newdriver(vp->v_bfs_e, vp->v_sdev, dp->dmap_driver)) != OK) { printf("VFSblock_spec_open: error sending driver endpoint\n"); } break; case I_NAMED_PIPE: vp->v_pipe = I_PIPE; oflags |= O_APPEND; /* force append mode */ fil_ptr->filp_flags = oflags; r = pipe_open(vp, bits, oflags); if (r != ENXIO) { /* See if someone else is doing a rd or wt on * the FIFO. If so, use its filp entry so the * file position will be automatically shared. */ b = (bits & R_BIT ? R_BIT : W_BIT); assert(fil_ptr->filp_count == 1); fil_ptr->filp_count = 0; /* don't find self */ if ((filp2 = find_filp(vp, b)) != NIL_FILP) { /* Co-reader or writer found. Use it.*/ fp->fp_filp[m_in.fd] = filp2; filp2->filp_count++; filp2->filp_vno = vp; filp2->filp_flags = oflags; /* v_count was incremented after the vnode has * been found, i_count was incremented incorrectly * by eatpath in FS, not knowing that we were going to * use an existing filp entry. Correct this error. */ put_vnode(vp); } else { /* Nobody else found. Claim filp. */ fil_ptr->filp_count = 1; } } break; } /* If error, release inode. */ if (r != OK) { if (r == SUSPEND) return(r); /* Oops, just suspended */ fp->fp_filp[m_in.fd] = NIL_FILP; FD_CLR(m_in.fd, &fp->fp_filp_inuse); fil_ptr->filp_count= 0; put_vnode(vp); fil_ptr->filp_vno = NIL_VNODE; return(r); } return(m_in.fd); } /*===========================================================================* * create_open * *===========================================================================*/ PRIVATE int create_open(omode, excl, vpp, created) mode_t omode; int excl; struct vnode **vpp; int *created; { int i, r, r1; size_t len; struct vnode *vp, *dir_vp, *new_vp, *start_vp; struct node_details res; char lastc[PATH_MAX+1]; if(!fp->fp_rd || !fp->fp_wd) { printf("VFS: %d: no rd/wd\n", fp->fp_endpoint); return ENOENT; } start_vp = (user_fullpath[0] == '/' ? fp->fp_rd : fp->fp_wd); dup_vnode(start_vp); for (i= 0; i sizeof(lastc)) { put_vnode(dir_vp); return ENAMETOOLONG; } memcpy(lastc, user_fullpath, len); /* Get a free vnode */ new_vp = get_free_vnode(__FILE__, __LINE__); if (new_vp == NIL_VNODE) { put_vnode(dir_vp); printf("vfs:create_open: no free vnode available\n"); return EINVAL; } r= forbidden(dir_vp, W_BIT|X_BIT, 0 /*!use_realuid*/); if (r == OK) { /* Try to create the file */ r= req_create(dir_vp->v_fs_e, dir_vp->v_inode_nr, omode, fp->fp_effuid, fp->fp_effgid, lastc, &res); } if (r != EEXIST && r != EACCES) { put_vnode(dir_vp); if (r != OK) return r; /* Check whether vnode is already in use or not */ vp = find_vnode(res.fs_e, res.inode_nr); if (vp != NIL_VNODE) { vp->v_ref_count++; vp->v_fs_count++; } else { vp= new_vp; /* Fill in the free vnode's fields */ vp->v_fs_e = res.fs_e; vp->v_inode_nr = res.inode_nr; vp->v_mode = res.fmode; vp->v_size = res.fsize; vp->v_uid = res.uid; vp->v_gid = res.gid; vp->v_sdev = res.dev; vp->v_vmnt = dir_vp->v_vmnt; vp->v_dev = vp->v_vmnt->m_dev; vp->v_fs_count = 1; vp->v_ref_count = 1; } *vpp= vp; *created= TRUE; return OK; } if (r == EEXIST && excl) { #if 0 printf( "vfs:create_open: creating existing file with O_EXCL\n"); #endif put_vnode(dir_vp); return r; } /* Try a regular lookup */ memcpy(user_fullpath, lastc, len); r1= lookup_rel_vp(dir_vp, 0 /*flags*/, 0 /*!use_realuid*/, &vp); if (r1 != ENOENT) { put_vnode(dir_vp); if (r1 == OK) { *vpp= vp; *created= FALSE; } return r1; } if (r == EACCES) { /* We cannot create a new file and the file does not * already exist. */ put_vnode(dir_vp); return r; } /* The create failed with EEXIST and the regular lookup * failed with ENOENT. We have to see whether the object * we try to access actually exists, but is a symlink that * cannot be resolved. If the symlink exists, we start * with the contents of the symlink. */ memcpy(user_fullpath, lastc, len); r= lookup_rel_vp(dir_vp, PATH_RET_SYMLINK, 0 /*!use_realuid*/, &vp); if (r != OK) { put_vnode(dir_vp); return r; } if (!S_ISLNK(vp->v_mode)) { /* Strange, we got an object, but it is not a symlink. * Well, just return the object. */ put_vnode(dir_vp); *vpp= vp; *created= FALSE; return OK; } /* Get the contents of the link */ len= sizeof(user_fullpath); r= req_rdlink(vp->v_fs_e, vp->v_inode_nr, FS_PROC_NR, (vir_bytes)user_fullpath, len-1); put_vnode(vp); if (r < 0) { printf("vfs:create_open: req_rdlink failed with %d\n", r); put_vnode(dir_vp); return r; } if (r >= len) { printf( "vfs:create_open: got bad length %d from req_rdlink\n", r); r= len-1; } user_fullpath[r]= '\0'; printf("got link target '%s'\n", user_fullpath); if (user_fullpath[0] == '/') { put_vnode(dir_vp); start_vp= fp->fp_rd; dup_vnode(start_vp); } else start_vp= dir_vp; } put_vnode(start_vp); return ELOOP; } /*===========================================================================* * exists_open * *===========================================================================*/ PRIVATE int exists_open(vp, bits, oflags /*, omode, lastc, vpp */) struct vnode *vp; mode_t bits; int oflags; { int r; /* Check protections. */ if ((r = forbidden(vp, bits, 0 /*!use_realuid*/)) != OK) return r; /* Opening reg. files directories and special files differ. */ switch (vp->v_mode & I_TYPE) { case I_REGULAR: /* Truncate regular file if O_TRUNC. */ if (oflags & O_TRUNC) { if ((r = forbidden(vp, W_BIT, 0 /*!use_realuid*/)) !=OK) break; truncate_vn(vp, 0); } break; case I_DIRECTORY: /* Directories may be read but not written. */ r = (bits & W_BIT ? EISDIR : OK); break; case I_CHAR_SPECIAL: case I_BLOCK_SPECIAL: if (vp->v_sdev == (dev_t)-1) panic(__FILE__, "vfs:exists_open: bad special", NO_NUM); break; case I_NAMED_PIPE: #if 0 printf("vfs:exists_open: fifo vp 0x%x, for %s\n", vp, ((bits & W_BIT) ? "writing" : "reading")); #endif if (vp->v_ref_count == 1) { vp->v_pipe_rd_pos= 0; vp->v_pipe_wr_pos= 0; if (vp->v_size != 0) r= truncate_vn(vp, 0); } break; } return(r); } /*===========================================================================* * pipe_open * *===========================================================================*/ PRIVATE int pipe_open(register struct vnode *vp, register mode_t bits, register int oflags) { /* This function is called from common_open. It checks if * there is at least one reader/writer pair for the pipe, if not * it suspends the caller, otherwise it revives all other blocked * processes hanging on the pipe. */ vp->v_pipe = I_PIPE; if((bits & (R_BIT|W_BIT)) == (R_BIT|W_BIT)) { printf("pipe opened RW.\n"); return ENXIO; } if (find_filp(vp, bits & W_BIT ? R_BIT : W_BIT) == NIL_FILP) { if (oflags & O_NONBLOCK) { if (bits & W_BIT) return(ENXIO); } else { suspend(FP_BLOCKED_ON_POPEN); /* suspend caller */ return(SUSPEND); } } else if (susp_count > 0) {/* revive blocked processes */ release(vp, OPEN, susp_count); release(vp, CREAT, susp_count); } return(OK); } /*===========================================================================* * do_mknod * *===========================================================================*/ PUBLIC int do_mknod() { /* Perform the mknod(name, mode, addr) system call. */ register mode_t bits, mode_bits; int r; struct vnode *vp; /* Only the super_user may make nodes other than fifos. */ mode_bits = (mode_t) m_in.mk_mode; /* mode of the inode */ if (!super_user && ((mode_bits & I_TYPE) != I_NAMED_PIPE)) return(EPERM); if (fetch_name(m_in.name1, m_in.name1_length, M1) != OK) return(err_code); bits = (mode_bits & I_TYPE) | (mode_bits & ALL_MODES & fp->fp_umask); /* Request lookup */ if ((r = lookup_lastdir(0 /*!use_realuid*/, &vp)) != OK) return r; /* Make sure that the object is a directory */ if ((vp->v_mode & I_TYPE) != I_DIRECTORY) { put_vnode(vp); return ENOTDIR; } r= forbidden(vp, W_BIT|X_BIT, 0 /*!use_realuid*/); if (r != OK) { put_vnode(vp); return r; } /* Issue request */ r= req_mknod(vp->v_fs_e, vp->v_inode_nr, user_fullpath, fp->fp_effuid, fp->fp_effgid, bits, m_in.mk_z0); put_vnode(vp); return r; } /*===========================================================================* * do_mkdir * *===========================================================================*/ PUBLIC int do_mkdir() { /* Perform the mkdir(name, mode) system call. */ mode_t bits; /* mode bits for the new inode */ int r; struct vnode *vp; if (fetch_name(m_in.name1, m_in.name1_length, M1) != OK) return(err_code); bits = I_DIRECTORY | (m_in.mode & RWX_MODES & fp->fp_umask); /* Request lookup */ if ((r = lookup_lastdir(0 /*!use_realuid*/, &vp)) != OK) return r; /* Make sure that the object is a directory */ if ((vp->v_mode & I_TYPE) != I_DIRECTORY) { put_vnode(vp); return ENOTDIR; } r= forbidden(vp, W_BIT|X_BIT, 0 /*!use_realuid*/); if (r != OK) { put_vnode(vp); return r; } /* Issue request */ r= req_mkdir(vp->v_fs_e, vp->v_inode_nr, user_fullpath, fp->fp_effuid, fp->fp_effgid, bits); put_vnode(vp); return r; } /*===========================================================================* * do_lseek * *===========================================================================*/ PUBLIC int do_lseek() { /* Perform the lseek(ls_fd, offset, whence) system call. */ register struct filp *rfilp; int r; long offset; u64_t pos, newpos; /* Check to see if the file descriptor is valid. */ if ( (rfilp = get_filp(m_in.ls_fd)) == NIL_FILP) return(err_code); /* No lseek on pipes. */ if (rfilp->filp_vno->v_pipe == I_PIPE) return(ESPIPE); /* The value of 'whence' determines the start position to use. */ switch(m_in.whence) { case SEEK_SET: pos = cvu64(0); break; case SEEK_CUR: pos = rfilp->filp_pos; break; case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break; default: return(EINVAL); } offset= m_in.offset_lo; if (offset >= 0) newpos= add64ul(pos, offset); else newpos= sub64ul(pos, -offset); /* Check for overflow. */ if (ex64hi(newpos) != 0) return EINVAL; if (cmp64(newpos, rfilp->filp_pos) != 0) { /* Inhibit read ahead request */ r = req_inhibread(rfilp->filp_vno->v_fs_e, rfilp->filp_vno->v_inode_nr); if (r != OK) return r; } rfilp->filp_pos = newpos; /* insert the new position into the output message */ m_out.reply_l1 = ex64lo(newpos); return(OK); } /*===========================================================================* * do_llseek * *===========================================================================*/ PUBLIC int do_llseek() { /* Perform the llseek(ls_fd, offset, whence) system call. */ register struct filp *rfilp; u64_t pos, newpos; int r; /* Check to see if the file descriptor is valid. */ if ( (rfilp = get_filp(m_in.ls_fd)) == NIL_FILP) return(err_code); /* No lseek on pipes. */ if (rfilp->filp_vno->v_pipe == I_PIPE) return(ESPIPE); /* The value of 'whence' determines the start position to use. */ switch(m_in.whence) { case SEEK_SET: pos = cvu64(0); break; case SEEK_CUR: pos = rfilp->filp_pos; break; case SEEK_END: pos = cvul64(rfilp->filp_vno->v_size); break; default: return(EINVAL); } newpos= add64(pos, make64(m_in.offset_lo, m_in.offset_high)); /* Check for overflow. */ if (((long)m_in.offset_high > 0) && cmp64(newpos, pos) < 0) return(EINVAL); if (((long)m_in.offset_high < 0) && cmp64(newpos, pos) > 0) return(EINVAL); if (cmp64(newpos, rfilp->filp_pos) != 0) { /* Inhibit read ahead request */ r = req_inhibread(rfilp->filp_vno->v_fs_e, rfilp->filp_vno->v_inode_nr); if (r != OK) return r; } rfilp->filp_pos = newpos; m_out.reply_l1 = ex64lo(newpos); m_out.reply_l2 = ex64hi(newpos); return(OK); } /*===========================================================================* * do_close * *===========================================================================*/ PUBLIC int do_close() { /* Perform the close(fd) system call. */ return close_fd(fp, m_in.fd); } /*===========================================================================* * close_fd * *===========================================================================*/ PUBLIC int close_fd(rfp, fd_nr) struct fproc *rfp; int fd_nr; { /* Perform the close(fd) system call. */ register struct filp *rfilp; register struct vnode *vp; struct file_lock *flp; int lock_count; /* First locate the vnode that belongs to the file descriptor. */ if ( (rfilp = get_filp2(rfp, fd_nr)) == NIL_FILP) return(err_code); vp = rfilp->filp_vno; close_filp(rfilp); FD_CLR(fd_nr, &rfp->fp_cloexec_set); rfp->fp_filp[fd_nr] = NIL_FILP; FD_CLR(fd_nr, &rfp->fp_filp_inuse); /* Check to see if the file is locked. If so, release all locks. */ if (nr_locks == 0) return(OK); lock_count = nr_locks; /* save count of locks */ for (flp = &file_lock[0]; flp < &file_lock[NR_LOCKS]; flp++) { if (flp->lock_type == 0) continue; /* slot not in use */ if (flp->lock_vnode == vp && flp->lock_pid == rfp->fp_pid) { flp->lock_type = 0; nr_locks--; } } if (nr_locks < lock_count) lock_revive(); /* lock released */ return(OK); } /*===========================================================================* * close_filp * *===========================================================================*/ PUBLIC void close_filp(fp) struct filp *fp; { int mode_word, rw; dev_t dev; struct vnode *vp; vp = fp->filp_vno; if (fp->filp_count - 1 == 0 && fp->filp_mode != FILP_CLOSED) { /* Check to see if the file is special. */ mode_word = vp->v_mode & I_TYPE; if (mode_word == I_CHAR_SPECIAL || mode_word == I_BLOCK_SPECIAL) { dev = (dev_t) vp->v_sdev; if (mode_word == I_BLOCK_SPECIAL) { if (vp->v_bfs_e == ROOT_FS_E) { /* Invalidate the cache unless the special is * mounted. Assume that the root filesystem's * is open only for fsck. */ req_flush(vp->v_bfs_e, dev); } } /* Do any special processing on device close. */ (void) dev_close(dev, fp-filp); /* Ignore any errors, even SUSPEND. */ } } /* If the inode being closed is a pipe, release everyone hanging on it. */ if (vp->v_pipe == I_PIPE) { rw = (fp->filp_mode & R_BIT ? WRITE : READ); release(vp, rw, NR_PROCS); } /* If a write has been done, the inode is already marked as DIRTY. */ if (--fp->filp_count == 0) { if (vp->v_pipe == I_PIPE) { /* Last reader or writer is going. Tell MFS about latest * pipe size. */ truncate_vn(vp, vp->v_size); } put_vnode(fp->filp_vno); } } /*===========================================================================* * close_reply * *===========================================================================*/ PUBLIC void close_reply() { /* No need to do anything */ } /*===========================================================================* * do_vm_open * *===========================================================================*/ PUBLIC int do_vm_open() { int len, r, n; endpoint_t ep; len = m_in.VMVO_NAME_LENGTH; m_out.VMV_ENDPOINT = ep = m_in.VMVO_ENDPOINT; /* Do open() call on behalf of any process, performed by VM. */ if(len < 2 || len > sizeof(user_fullpath)) { printf("do_vm_open: strange length %d\n", len); m_out.VMVRO_FD = EINVAL; return VM_VFS_REPLY_OPEN; } /* Do open on behalf of which process? */ if(isokendpt(ep, &n) != OK) { printf("do_vm_open: strange endpoint %d\n", ep); m_out.VMVRO_FD = EINVAL; return VM_VFS_REPLY_OPEN; } /* XXX - do open on behalf of this process */ fp = &fproc[n]; /* Get path name from VM address space. */ if((r=sys_safecopyfrom(VM_PROC_NR, m_in.VMVO_NAME_GRANT, 0, (vir_bytes) user_fullpath, len, D)) != OK) { printf("do_vm_open: sys_safecopyfrom failed: %d\n", r); m_out.VMVRO_FD = EPERM; return VM_VFS_REPLY_OPEN; } /* Check if path is null-terminated. */ if(user_fullpath[len-1] != '\0') { printf("do_vm_open: name (len %d) not 0-terminated\n", len); m_out.VMVRO_FD = EINVAL; return VM_VFS_REPLY_OPEN; } /* Perform open(). */ m_out.VMVRO_FD = common_open(m_in.VMVO_FLAGS, m_in.VMVO_MODE); m_out.VMV_ENDPOINT = ep; /* Send open() reply. */ return VM_VFS_REPLY_OPEN; } /*===========================================================================* * do_vm_close * *===========================================================================*/ PUBLIC int do_vm_close() { int len, r, n; endpoint_t ep; len = m_in.VMVO_NAME_LENGTH; /* Do close() call on behalf of any process, performed by VM. */ m_out.VMV_ENDPOINT = ep = m_in.VMVC_ENDPOINT; if(isokendpt(ep, &n) != OK) { printf("do_vm_close: strange endpoint %d\n", ep); return VM_VFS_REPLY_CLOSE; } /* Perform close(). */ r = close_fd(&fproc[n], m_in.VMVC_FD); return VM_VFS_REPLY_CLOSE; }