cregit-Linux how code gets into the kernel

Release 4.10 fs/ufs/namei.c

Directory: fs/ufs
 * linux/fs/ufs/namei.c
 * Migration to usage of "page cache" on May 2006 by
 * Evgeniy Dushistov <> based on ext2 code base.
 * Copyright (C) 1998
 * Daniel Pirkl <>
 * Charles University, Faculty of Mathematics and Physics
 *  from
 *  linux/fs/ext2/namei.c
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *  from
 *  linux/fs/minix/namei.c
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (, 1995

#include <linux/time.h>
#include <linux/fs.h>

#include "ufs_fs.h"
#include "ufs.h"
#include "util.h"

static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode) { int err = ufs_add_link(dentry, inode); if (!err) { unlock_new_inode(inode); d_instantiate(dentry, inode); return 0; } inode_dec_link_count(inode); unlock_new_inode(inode); iput(inode); return err; }


linus torvaldslinus torvalds3653.73%125.00%
al viroal viro1014.93%125.00%
alexey dobriyanalexey dobriyan11.49%125.00%

static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags) { struct inode * inode = NULL; ino_t ino; if (dentry->d_name.len > UFS_MAXNAMLEN) return ERR_PTR(-ENAMETOOLONG); ino = ufs_inode_by_name(dir, &dentry->d_name); if (ino) inode = ufs_iget(dir->i_sb, ino); return d_splice_alias(inode, dentry); }


linus torvaldslinus torvalds3035.71%114.29%
al viroal viro78.33%228.57%
alexey dobriyanalexey dobriyan33.57%114.29%
david howellsdavid howells11.19%114.29%
trond myklebusttrond myklebust11.19%114.29%

/* * By the time this is called, we already have created * the directory cache entry for the new file, but it * is so far negative - it has no inode. * * If the create succeeds, we fill in the inode information * with d_instantiate(). */
static int ufs_create (struct inode * dir, struct dentry * dentry, umode_t mode, bool excl) { struct inode *inode; inode = ufs_new_inode(dir, mode); if (IS_ERR(inode)) return PTR_ERR(inode); inode->i_op = &ufs_file_inode_operations; inode->i_fop = &ufs_file_operations; inode->i_mapping->a_ops = &ufs_aops; mark_inode_dirty(inode); return ufs_add_nondir(dentry, inode); }


linus torvaldslinus torvalds2832.94%112.50%
al viroal viro1011.76%337.50%
evgeniy dushistovevgeniy dushistov44.71%112.50%
trond myklebusttrond myklebust11.18%112.50%

static int ufs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev) { struct inode *inode; int err; if (!old_valid_dev(rdev)) return -EINVAL; inode = ufs_new_inode(dir, mode); err = PTR_ERR(inode); if (!IS_ERR(inode)) { init_special_inode(inode, mode, rdev); ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev); mark_inode_dirty(inode); err = ufs_add_nondir(dentry, inode); } return err; }


linus torvaldslinus torvalds5147.22%111.11%
al viroal viro2624.07%333.33%
andries brouwerandries brouwer65.56%222.22%
alex kiernanalex kiernan54.63%111.11%

static int ufs_symlink (struct inode * dir, struct dentry * dentry, const char * symname) { struct super_block * sb = dir->i_sb; int err; unsigned l = strlen(symname)+1; struct inode * inode; if (l > sb->s_blocksize) return -ENAMETOOLONG; inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO); err = PTR_ERR(inode); if (IS_ERR(inode)) return err; if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) { /* slow symlink */ inode->i_op = &page_symlink_inode_operations; inode_nohighmem(inode); inode->i_mapping->a_ops = &ufs_aops; err = page_symlink(inode, symname, l); if (err) goto out_fail; } else { /* fast symlink */ inode->i_op = &simple_symlink_inode_operations; inode->i_link = (char *)UFS_I(inode)->i_u1.i_symlink; memcpy(inode->i_link, symname, l); inode->i_size = l-1; } mark_inode_dirty(inode); return ufs_add_nondir(dentry, inode); out_fail: inode_dec_link_count(inode); unlock_new_inode(inode); iput(inode); return err; }


linus torvaldslinus torvalds9944.39%215.38%
al viroal viro3716.59%538.46%
dave jonesdave jones31.35%17.69%
andrew mortonandrew morton10.45%17.69%
alexey dobriyanalexey dobriyan10.45%17.69%
duane griffinduane griffin10.45%17.69%

static int ufs_link (struct dentry * old_dentry, struct inode * dir, struct dentry *dentry) { struct inode *inode = d_inode(old_dentry); int error; inode->i_ctime = current_time(inode); inode_inc_link_count(inode); ihold(inode); error = ufs_add_link(dentry, inode); if (error) { inode_dec_link_count(inode); iput(inode); } else d_instantiate(dentry, inode); return error; }


linus torvaldslinus torvalds3943.82%111.11%
jan karajan kara1820.22%111.11%
al viroal viro1011.24%222.22%
deepa dinamanideepa dinamani44.49%111.11%
david howellsdavid howells33.37%111.11%
arnd bergmannarnd bergmann22.25%111.11%
alexey dobriyanalexey dobriyan11.12%111.11%

static int ufs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode) { struct inode * inode; int err; inode_inc_link_count(dir); inode = ufs_new_inode(dir, S_IFDIR|mode); err = PTR_ERR(inode); if (IS_ERR(inode)) goto out_dir; inode->i_op = &ufs_dir_inode_operations; inode->i_fop = &ufs_dir_operations; inode->i_mapping->a_ops = &ufs_aops; inode_inc_link_count(inode); err = ufs_make_empty(inode, dir); if (err) goto out_fail; err = ufs_add_link(dentry, inode); if (err) goto out_fail; unlock_new_inode(inode); d_instantiate(dentry, inode); return 0; out_fail: inode_dec_link_count(inode); inode_dec_link_count(inode); unlock_new_inode(inode); iput (inode); out_dir: inode_dec_link_count(dir); return err; }


linus torvaldslinus torvalds3520.96%17.14%
fabian frederickfabian frederick1710.18%17.14%
al viroal viro116.59%428.57%
evgeniy dushistovevgeniy dushistov95.39%17.14%
alexey dobriyanalexey dobriyan42.40%17.14%
arnd bergmannarnd bergmann21.20%17.14%
jan karajan kara21.20%17.14%

static int ufs_unlink(struct inode *dir, struct dentry *dentry) { struct inode * inode = d_inode(dentry); struct ufs_dir_entry *de; struct page *page; int err = -ENOENT; de = ufs_find_entry(dir, &dentry->d_name, &page); if (!de) goto out; err = ufs_delete_entry(dir, de, page); if (err) goto out; inode->i_ctime = dir->i_ctime; inode_dec_link_count(inode); err = 0; out: return err; }


linus torvaldslinus torvalds4946.67%111.11%
evgeniy dushistovevgeniy dushistov87.62%111.11%
alexey dobriyanalexey dobriyan43.81%222.22%
david howellsdavid howells32.86%111.11%

static int ufs_rmdir (struct inode * dir, struct dentry *dentry) { struct inode * inode = d_inode(dentry); int err= -ENOTEMPTY; if (ufs_empty_dir (inode)) { err = ufs_unlink(dir, dentry); if (!err) { inode->i_size = 0; inode_dec_link_count(inode); inode_dec_link_count(dir); } } return err; }


linus torvaldslinus torvalds4153.95%116.67%
david howellsdavid howells33.95%116.67%
alexey dobriyanalexey dobriyan22.63%116.67%

static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry, unsigned int flags) { struct inode *old_inode = d_inode(old_dentry); struct inode *new_inode = d_inode(new_dentry); struct page *dir_page = NULL; struct ufs_dir_entry * dir_de = NULL; struct page *old_page; struct ufs_dir_entry *old_de; int err = -ENOENT; if (flags & ~RENAME_NOREPLACE) return -EINVAL; old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page); if (!old_de) goto out; if (S_ISDIR(old_inode->i_mode)) { err = -EIO; dir_de = ufs_dotdot(old_inode, &dir_page); if (!dir_de) goto out_old; } if (new_inode) { struct page *new_page; struct ufs_dir_entry *new_de; err = -ENOTEMPTY; if (dir_de && !ufs_empty_dir(new_inode)) goto out_dir; err = -ENOENT; new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page); if (!new_de) goto out_dir; ufs_set_link(new_dir, new_de, new_page, old_inode, 1); new_inode->i_ctime = current_time(new_inode); if (dir_de) drop_nlink(new_inode); inode_dec_link_count(new_inode); } else { err = ufs_add_link(new_dentry, old_inode); if (err) goto out_dir; if (dir_de) inode_inc_link_count(new_dir); } /* * Like most other Unix systems, set the ctime for inodes on a * rename. */ old_inode->i_ctime = current_time(old_inode); ufs_delete_entry(old_dir, old_de, old_page); mark_inode_dirty(old_inode); if (dir_de) { if (old_dir != new_dir) ufs_set_link(old_inode, dir_de, dir_page, new_dir, 0); else { kunmap(dir_page); put_page(dir_page); } inode_dec_link_count(old_dir); } return 0; out_dir: if (dir_de) { kunmap(dir_page); put_page(dir_page); } out_old: kunmap(old_page); put_page(old_page); out: return err; }


linus torvaldslinus torvalds10226.91%16.67%
evgeniy dushistovevgeniy dushistov359.23%16.67%
al viroal viro246.33%213.33%
miklos szeredimiklos szeredi153.96%16.67%
alexey dobriyanalexey dobriyan92.37%213.33%
deepa dinamanideepa dinamani82.11%16.67%
david howellsdavid howells61.58%16.67%
dave hansendave hansen30.79%16.67%
kirill a. shutemovkirill a. shutemov30.79%16.67%

const struct inode_operations ufs_dir_inode_operations = { .create = ufs_create, .lookup = ufs_lookup, .link = ufs_link, .unlink = ufs_unlink, .symlink = ufs_symlink, .mkdir = ufs_mkdir, .rmdir = ufs_rmdir, .mknod = ufs_mknod, .rename = ufs_rename, };

Overall Contributors

linus torvaldslinus torvalds51135.19%23.51%
al viroal viro1359.30%1831.58%
evgeniy dushistovevgeniy dushistov573.93%35.26%
alexey dobriyanalexey dobriyan251.72%23.51%
jan karajan kara201.38%23.51%
art haasart haas181.24%11.75%
fabian frederickfabian frederick171.17%11.75%
david howellsdavid howells161.10%23.51%
miklos szeredimiklos szeredi151.03%11.75%
deepa dinamanideepa dinamani120.83%11.75%
alex kiernanalex kiernan80.55%11.75%
andries brouwerandries brouwer60.41%23.51%
arnd bergmannarnd bergmann40.28%11.75%
dave jonesdave jones40.28%23.51%
kirill a. shutemovkirill a. shutemov30.21%11.75%
christoph hellwigchristoph hellwig30.21%23.51%
dave hansendave hansen30.21%11.75%
trond myklebusttrond myklebust20.14%23.51%
duane griffinduane griffin10.07%11.75%
mike frysingermike frysinger10.07%11.75%
arjan van de venarjan van de ven10.07%11.75%
andrew mortonandrew morton10.07%11.75%
Directory: fs/ufs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.