Lemur zaprasza
/* * linux/fs/namei.c * * Copyright (C) 1991, 1992 Linus Torvalds */ /* * Some corrections by tytso. */ #include <asm/segment.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/kernel.h> #include <linux/string.h> #include <linux/fcntl.h> #include <linux/stat.h> #include <linux/mm.h> #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE]) /* * How long a filename can we get from user space? * -EFAULT if invalid area * 0 if ok (ENAMETOOLONG before EFAULT) * >0 EFAULT after xx bytes */ static inline int get_max_filename(unsigned long address) { struct vm_area_struct * vma; if (get_fs() == KERNEL_DS) return 0; vma = find_vma(current, address); if (!vma || vma->vm_start > address || !(vma->vm_flags & VM_READ)) return -EFAULT; address = vma->vm_end - address; if (address > PAGE_SIZE) return 0; if (vma->vm_next && vma->vm_next->vm_start == vma->vm_end && (vma->vm_next->vm_flags & VM_READ)) return 0; return address; } /* * In order to reduce some races, while at the same time doing additional * checking and hopefully speeding things up, we copy filenames to the * kernel data space before using them.. * * POSIX.1 2.4: an empty pathname is invalid (ENOENT). */ int getname(const char * filename, char **result) { int i, error; unsigned long page; char * tmp, c; i = get_max_filename((unsigned long) filename); if (i < 0) return i; error = -EFAULT; if (!i) { error = -ENAMETOOLONG; i = PAGE_SIZE; } c = get_user(filename++); if (!c) return -ENOENT; if(!(page = __get_free_page(GFP_KERNEL))) return -ENOMEM; *result = tmp = (char *) page; while (--i) { *(tmp++) = c; c = get_user(filename++); if (!c) { *tmp = '\0'; return 0; } } free_page(page); return error; } void putname(char * name) { free_page((unsigned long) name); } /* * permission() * * is used to check for read/write/execute permissions on a file. * We use "fsuid" for this, letting us set arbitrary permissions * for filesystem access without changing the "normal" uids which * are used for other things.. */ int permission(struct inode * inode,int mask) { int mode = inode->i_mode; if (inode->i_op && inode->i_op->permission) return inode->i_op->permission(inode, mask); else if ((mask & S_IWOTH) && IS_IMMUTABLE(inode)) return -EACCES; /* Nobody gets write access to an immutable file */ else if (current->fsuid == inode->i_uid) mode >>= 6; else if (in_group_p(inode->i_gid)) mode >>= 3; if (((mode & mask & 0007) == mask) || fsuser()) return 0; return -EACCES; } /* * get_write_access() gets write permission for a file. * put_write_access() releases this write permission. * This is used for regular files. * We cannot support write (and maybe mmap read-write shared) accesses and * MAP_DENYWRITE mmappings simultaneously. */ int get_write_access(struct inode * inode) { struct task_struct * p; if ((inode->i_count > 1) && S_ISREG(inode->i_mode)) /* shortcut */ for_each_task(p) { struct vm_area_struct * mpnt; if (!p->mm) continue; for(mpnt = p->mm->mmap; mpnt; mpnt = mpnt->vm_next) { if (inode != mpnt->vm_inode) continue; if (mpnt->vm_flags & VM_DENYWRITE) return -ETXTBSY; } } inode->i_writecount++; return 0; } void put_write_access(struct inode * inode) { inode->i_writecount--; } /* * lookup() looks up one part of a pathname, using the fs-dependent * routines (currently minix_lookup) for it. It also checks for * fathers (pseudo-roots, mount-points) */ int lookup(struct inode * dir,const char * name, int len, struct inode ** result) { struct super_block * sb; int perm; *result = NULL; if (!dir) return -ENOENT; /* check permissions before traversing mount-points */ perm = permission(dir,MAY_EXEC); if (len==2 && name[0] == '.' && name[1] == '.') { if (dir == current->fs->root) { *result = dir; return 0; } else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) { iput(dir); dir = sb->s_covered; if (!dir) return -ENOENT; dir->i_count++; } } if (!dir->i_op || !dir->i_op->lookup) { iput(dir); return -ENOTDIR; } if (perm != 0) { iput(dir); return perm; } if (!len) { *result = dir; return 0; } return dir->i_op->lookup(dir, name, len, result); } int follow_link(struct inode * dir, struct inode * inode, int flag, int mode, struct inode ** res_inode) { if (!dir || !inode) { iput(dir); iput(inode); *res_inode = NULL; return -ENOENT; } if (!inode->i_op || !inode->i_op->follow_link) { iput(dir); *res_inode = inode; return 0; } return inode->i_op->follow_link(dir,inode,flag,mode,res_inode); } /* * dir_namei() * * dir_namei() returns the inode of the directory of the * specified name, and the name within that directory. */ static int dir_namei(const char *pathname, int *namelen, const char **name, struct inode * base, struct inode **res_inode) { char c; const char * thisname; int len,error; struct inode * inode; *res_inode = NULL; if (!base) { base = current->fs->pwd; base->i_count++; } if ((c = *pathname) == '/') { iput(base); base = current->fs->root; pathname++; base->i_count++; } while (1) { thisname = pathname; for(len=0;(c = *(pathname++))&&(c != '/');len++) /* nothing */ ; if (!c) break; base->i_count++; error = lookup(base, thisname, len, &inode); if (error) { iput(base); return error; } error = follow_link(base,inode,0,0,&base); if (error) return error; } if (!base->i_op || !base->i_op->lookup) { iput(base); return -ENOTDIR; } *name = thisname; *namelen = len; *res_inode = base; return 0; } static int _namei(const char * pathname, struct inode * base, int follow_links, struct inode ** res_inode) { const char *basename; int namelen,error; struct inode * inode; *res_inode = NULL; error = dir_namei(pathname, &namelen, &basename, base, &base); if (error) return error; base->i_count++; /* lookup uses up base */ error = lookup(base, basename, namelen, &inode); if (error) { iput(base); return error; } if (follow_links) { error = follow_link(base, inode, 0, 0, &inode); if (error) return error; } else iput(base); *res_inode = inode; return 0; } int lnamei(const char *pathname, struct inode **res_inode) { int error; char * tmp; error = getname(pathname, &tmp); if (!error) { error = _namei(tmp, NULL, 0, res_inode); putname(tmp); } return error; } /* * namei() * * is used by most simple commands to get the inode of a specified name. * Open, link etc use their own routines, but this is enough for things * like 'chmod' etc. */ int namei(const char *pathname, struct inode **res_inode) { int error; char * tmp; error = getname(pathname, &tmp); if (!error) { error = _namei(tmp, NULL, 1, res_inode); putname(tmp); } return error; } /* * open_namei() * * namei for open - this is in fact almost the whole open-routine. * * Note that the low bits of "flag" aren't the same as in the open * system call - they are 00 - no permissions needed * 01 - read permission needed * 10 - write permission needed * 11 - read/write permissions needed * which is a lot more logical, and also allows the "no perm" needed * for symlinks (where the permissions are checked later). */ int open_namei(const char * pathname, int flag, int mode, struct inode ** res_inode, struct inode * base) { const char * basename; int namelen,error; struct inode * dir, *inode; mode &= S_IALLUGO & ~current->fs->umask; mode |= S_IFREG; error = dir_namei(pathname, &namelen, &basename, base, &dir); if (error) return error; if (!namelen) { /* special case: '/usr/' etc */ if (flag & 2) { iput(dir); return -EISDIR; } /* thanks to Paul Pluzhnikov for noticing this was missing.. */ if ((error = permission(dir,ACC_MODE(flag))) != 0) { iput(dir); return error; } *res_inode=dir; return 0; } dir->i_count++; /* lookup eats the dir */ if (flag & O_CREAT) { down(&dir->i_sem); error = lookup(dir, basename, namelen, &inode); if (!error) { if (flag & O_EXCL) { iput(inode); error = -EEXIST; } } else if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) ; /* error is already set! */ else if (!dir->i_op || !dir->i_op->create) error = -EACCES; else if (IS_RDONLY(dir)) error = -EROFS; else { dir->i_count++; /* create eats the dir */ if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); error = dir->i_op->create(dir, basename, namelen, mode, res_inode); up(&dir->i_sem); iput(dir); return error; } up(&dir->i_sem); } else error = lookup(dir, basename, namelen, &inode); if (error) { iput(dir); return error; } error = follow_link(dir,inode,flag,mode,&inode); if (error) return error; if (S_ISDIR(inode->i_mode) && (flag & 2)) { iput(inode); return -EISDIR; } if ((error = permission(inode,ACC_MODE(flag))) != 0) { iput(inode); return error; } if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { /* * 2-Feb-1995 Bruce Perens <Bruce@Pixar.com> * Allow opens of Unix domain sockets and FIFOs for write on * read-only filesystems. Their data does not live on the disk. * * If there was something like IS_NODEV(inode) for * pipes and/or sockets I'd check it here. */ } else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) { if (IS_NODEV(inode)) { iput(inode); return -EACCES; } flag &= ~O_TRUNC; } else { if (IS_RDONLY(inode) && (flag & 2)) { iput(inode); return -EROFS; } } /* * An append-only file must be opened in append mode for writing */ if (IS_APPEND(inode) && ((flag & FMODE_WRITE) && !(flag & O_APPEND))) { iput(inode); return -EPERM; } if (flag & O_TRUNC) { if ((error = get_write_access(inode))) { iput(inode); return error; } /* * Refuse to truncate files with mandatory locks held on them */ error = locks_verify_locked(inode); if (error) { iput(inode); return error; } if (inode->i_sb && inode->i_sb->dq_op) inode->i_sb->dq_op->initialize(inode, -1); error = do_truncate(inode, 0); put_write_access(inode); if (error) { iput(inode); return error; } } else if (flag & FMODE_WRITE) if (inode->i_sb && inode->i_sb->dq_op) inode->i_sb->dq_op->initialize(inode, -1); *res_inode = inode; return 0; } int do_mknod(const char * filename, int mode, dev_t dev) { const char * basename; int namelen, error; struct inode * dir; mode &= ~current->fs->umask; error = dir_namei(filename, &namelen, &basename, NULL, &dir); if (error) return error; if (!namelen) { iput(dir); return -ENOENT; } if (IS_RDONLY(dir)) { iput(dir); return -EROFS; } if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(dir); return error; } if (!dir->i_op || !dir->i_op->mknod) { iput(dir); return -EPERM; } dir->i_count++; if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); down(&dir->i_sem); error = dir->i_op->mknod(dir,basename,namelen,mode,dev); up(&dir->i_sem); iput(dir); return error; } asmlinkage int sys_mknod(const char * filename, int mode, dev_t dev) { int error; char * tmp; if (S_ISDIR(mode) || (!S_ISFIFO(mode) && !fsuser())) return -EPERM; switch (mode & S_IFMT) { case 0: mode |= S_IFREG; break; case S_IFREG: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK: break; default: return -EINVAL; } error = getname(filename,&tmp); if (!error) { error = do_mknod(tmp,mode,dev); putname(tmp); } return error; } static int do_mkdir(const char * pathname, int mode) { const char * basename; int namelen, error; struct inode * dir; error = dir_namei(pathname, &namelen, &basename, NULL, &dir); if (error) return error; if (!namelen) { iput(dir); return -ENOENT; } if (IS_RDONLY(dir)) { iput(dir); return -EROFS; } if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(dir); return error; } if (!dir->i_op || !dir->i_op->mkdir) { iput(dir); return -EPERM; } dir->i_count++; if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); down(&dir->i_sem); error = dir->i_op->mkdir(dir, basename, namelen, mode & 0777 & ~current->fs->umask); up(&dir->i_sem); iput(dir); return error; } asmlinkage int sys_mkdir(const char * pathname, int mode) { int error; char * tmp; error = getname(pathname,&tmp); if (!error) { error = do_mkdir(tmp,mode); putname(tmp); } return error; } static int do_rmdir(const char * name) { const char * basename; int namelen, error; struct inode * dir; error = dir_namei(name, &namelen, &basename, NULL, &dir); if (error) return error; if (!namelen) { iput(dir); return -ENOENT; } if (IS_RDONLY(dir)) { iput(dir); return -EROFS; } if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(dir); return error; } /* * A subdirectory cannot be removed from an append-only directory */ if (IS_APPEND(dir)) { iput(dir); return -EPERM; } if (!dir->i_op || !dir->i_op->rmdir) { iput(dir); return -EPERM; } if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); return dir->i_op->rmdir(dir,basename,namelen); } asmlinkage int sys_rmdir(const char * pathname) { int error; char * tmp; error = getname(pathname,&tmp); if (!error) { error = do_rmdir(tmp); putname(tmp); } return error; } static int do_unlink(const char * name) { const char * basename; int namelen, error; struct inode * dir; error = dir_namei(name, &namelen, &basename, NULL, &dir); if (error) return error; if (!namelen) { iput(dir); return -EPERM; } if (IS_RDONLY(dir)) { iput(dir); return -EROFS; } if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(dir); return error; } /* * A file cannot be removed from an append-only directory */ if (IS_APPEND(dir)) { iput(dir); return -EPERM; } if (!dir->i_op || !dir->i_op->unlink) { iput(dir); return -EPERM; } if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); return dir->i_op->unlink(dir,basename,namelen); } asmlinkage int sys_unlink(const char * pathname) { int error; char * tmp; error = getname(pathname,&tmp); if (!error) { error = do_unlink(tmp); putname(tmp); } return error; } static int do_symlink(const char * oldname, const char * newname) { struct inode * dir; const char * basename; int namelen, error; error = dir_namei(newname, &namelen, &basename, NULL, &dir); if (error) return error; if (!namelen) { iput(dir); return -ENOENT; } if (IS_RDONLY(dir)) { iput(dir); return -EROFS; } if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(dir); return error; } if (!dir->i_op || !dir->i_op->symlink) { iput(dir); return -EPERM; } dir->i_count++; if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); down(&dir->i_sem); error = dir->i_op->symlink(dir,basename,namelen,oldname); up(&dir->i_sem); iput(dir); return error; } asmlinkage int sys_symlink(const char * oldname, const char * newname) { int error; char * from, * to; error = getname(oldname,&from); if (!error) { error = getname(newname,&to); if (!error) { error = do_symlink(from,to); putname(to); } putname(from); } return error; } static int do_link(struct inode * oldinode, const char * newname) { struct inode * dir; const char * basename; int namelen, error; error = dir_namei(newname, &namelen, &basename, NULL, &dir); if (error) { iput(oldinode); return error; } if (!namelen) { iput(oldinode); iput(dir); return -EPERM; } if (IS_RDONLY(dir)) { iput(oldinode); iput(dir); return -EROFS; } if (dir->i_dev != oldinode->i_dev) { iput(dir); iput(oldinode); return -EXDEV; } if ((error = permission(dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(dir); iput(oldinode); return error; } /* * A link to an append-only or immutable file cannot be created */ if (IS_APPEND(oldinode) || IS_IMMUTABLE(oldinode)) { iput(dir); iput(oldinode); return -EPERM; } if (!dir->i_op || !dir->i_op->link) { iput(dir); iput(oldinode); return -EPERM; } dir->i_count++; if (dir->i_sb && dir->i_sb->dq_op) dir->i_sb->dq_op->initialize(dir, -1); down(&dir->i_sem); error = dir->i_op->link(oldinode, dir, basename, namelen); up(&dir->i_sem); iput(dir); return error; } asmlinkage int sys_link(const char * oldname, const char * newname) { int error; char * to; struct inode * oldinode; error = lnamei(oldname, &oldinode); if (error) return error; error = getname(newname,&to); if (error) { iput(oldinode); return error; } error = do_link(oldinode,to); putname(to); return error; } static int do_rename(const char * oldname, const char * newname) { struct inode * old_dir, * new_dir; const char * old_base, * new_base; int old_len, new_len, error; error = dir_namei(oldname, &old_len, &old_base, NULL, &old_dir); if (error) return error; if ((error = permission(old_dir,MAY_WRITE | MAY_EXEC)) != 0) { iput(old_dir); return error; } if (!old_len || (old_base[0] == '.' && (old_len == 1 || (old_base[1] == '.' && old_len == 2)))) { iput(old_dir); return -EPERM; } error = dir_namei(newname, &new_len, &new_base, NULL, &new_dir); if (error) { iput(old_dir); return error; } if ((error = permission(new_dir,MAY_WRITE | MAY_EXEC)) != 0){ iput(old_dir); iput(new_dir); return error; } if (!new_len || (new_base[0] == '.' && (new_len == 1 || (new_base[1] == '.' && new_len == 2)))) { iput(old_dir); iput(new_dir); return -EPERM; } if (new_dir->i_dev != old_dir->i_dev) { iput(old_dir); iput(new_dir); return -EXDEV; } if (IS_RDONLY(new_dir) || IS_RDONLY(old_dir)) { iput(old_dir); iput(new_dir); return -EROFS; } /* * A file cannot be removed from an append-only directory */ if (IS_APPEND(old_dir)) { iput(old_dir); iput(new_dir); return -EPERM; } if (!old_dir->i_op || !old_dir->i_op->rename) { iput(old_dir); iput(new_dir); return -EPERM; } new_dir->i_count++; if (new_dir->i_sb && new_dir->i_sb->dq_op) new_dir->i_sb->dq_op->initialize(new_dir, -1); down(&new_dir->i_sem); error = old_dir->i_op->rename(old_dir, old_base, old_len, new_dir, new_base, new_len); up(&new_dir->i_sem); iput(new_dir); return error; } asmlinkage int sys_rename(const char * oldname, const char * newname) { int error; char * from, * to; error = getname(oldname,&from); if (!error) { error = getname(newname,&to); if (!error) { error = do_rename(from,to); putname(to); } putname(from); } return error; } |