cregit-Linux how code gets into the kernel

Release 4.11 fs/sysv/inode.c

Directory: fs/sysv
/*
 *  linux/fs/sysv/inode.c
 *
 *  minix/inode.c
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  xenix/inode.c
 *  Copyright (C) 1992  Doug Evans
 *
 *  coh/inode.c
 *  Copyright (C) 1993  Pascal Haible, Bruno Haible
 *
 *  sysv/inode.c
 *  Copyright (C) 1993  Paul B. Monday
 *
 *  sysv/inode.c
 *  Copyright (C) 1993  Bruno Haible
 *  Copyright (C) 1997, 1998  Krzysztof G. Baranowski
 *
 *  This file contains code for allocating/freeing inodes and for read/writing
 *  the superblock.
 */

#include <linux/highuid.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/buffer_head.h>
#include <linux/vfs.h>
#include <linux/writeback.h>
#include <linux/namei.h>
#include <asm/byteorder.h>
#include "sysv.h"


static int sysv_sync_fs(struct super_block *sb, int wait) { struct sysv_sb_info *sbi = SYSV_SB(sb); unsigned long time = get_seconds(), old_time; mutex_lock(&sbi->s_lock); /* * If we are going to write out the super block, * then attach current time stamp. * But if the filesystem was marked clean, keep it clean. */ old_time = fs32_to_cpu(sbi, *sbi->s_sb_time); if (sbi->s_type == FSTYPE_SYSV4) { if (*sbi->s_sb_state == cpu_to_fs32(sbi, 0x7c269d38 - old_time)) *sbi->s_sb_state = cpu_to_fs32(sbi, 0x7c269d38 - time); *sbi->s_sb_time = cpu_to_fs32(sbi, time); mark_buffer_dirty(sbi->s_bh2); } mutex_unlock(&sbi->s_lock); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Christoph Hellwig5241.94%337.50%
Linus Torvalds4637.10%112.50%
Linus Torvalds (pre-git)1411.29%225.00%
Marco Stornelli108.06%112.50%
Andi Kleen21.61%112.50%
Total124100.00%8100.00%


static int sysv_remount(struct super_block *sb, int *flags, char *data) { struct sysv_sb_info *sbi = SYSV_SB(sb); sync_filesystem(sb); if (sbi->s_forced_ro) *flags |= MS_RDONLY; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro4389.58%150.00%
Theodore Y. Ts'o510.42%150.00%
Total48100.00%2100.00%


static void sysv_put_super(struct super_block *sb) { struct sysv_sb_info *sbi = SYSV_SB(sb); if (!(sb->s_flags & MS_RDONLY)) { /* XXX ext2 also updates the state here */ mark_buffer_dirty(sbi->s_bh1); if (sbi->s_bh1 != sbi->s_bh2) mark_buffer_dirty(sbi->s_bh2); } brelse(sbi->s_bh1); if (sbi->s_bh1 != sbi->s_bh2) brelse(sbi->s_bh2); kfree(sbi); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds5157.95%240.00%
Christoph Hellwig2932.95%240.00%
Linus Torvalds (pre-git)89.09%120.00%
Total88100.00%5100.00%


static int sysv_statfs(struct dentry *dentry, struct kstatfs *buf) { struct super_block *sb = dentry->d_sb; struct sysv_sb_info *sbi = SYSV_SB(sb); u64 id = huge_encode_dev(sb->s_bdev->bd_dev); buf->f_type = sb->s_magic; buf->f_bsize = sb->s_blocksize; buf->f_blocks = sbi->s_ndatazones; buf->f_bavail = buf->f_bfree = sysv_count_free_blocks(sb); buf->f_files = sbi->s_ninodes; buf->f_ffree = sysv_count_free_inodes(sb); buf->f_namelen = SYSV_NAMELEN; buf->f_fsid.val[0] = (u32)id; buf->f_fsid.val[1] = (u32)(id >> 32); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)4733.10%337.50%
Coly Li4430.99%112.50%
Linus Torvalds2517.61%112.50%
Christoph Hellwig149.86%112.50%
David Howells117.75%112.50%
Andrew Morton10.70%112.50%
Total142100.00%8100.00%

/* * NXI <-> N0XI for PDP, XIN <-> XIN0 for le32, NIX <-> 0NIX for be32 */
static inline void read3byte(struct sysv_sb_info *sbi, unsigned char * from, unsigned char * to) { if (sbi->s_bytesex == BYTESEX_PDP) { to[0] = from[0]; to[1] = 0; to[2] = from[1]; to[3] = from[2]; } else if (sbi->s_bytesex == BYTESEX_LE) { to[0] = from[0]; to[1] = from[1]; to[2] = from[2]; to[3] = 0; } else { to[0] = 0; to[1] = from[0]; to[2] = from[1]; to[3] = from[2]; } }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds10969.43%125.00%
Linus Torvalds (pre-git)4226.75%250.00%
Christoph Hellwig63.82%125.00%
Total157100.00%4100.00%


static inline void write3byte(struct sysv_sb_info *sbi, unsigned char * from, unsigned char * to) { if (sbi->s_bytesex == BYTESEX_PDP) { to[0] = from[0]; to[1] = from[2]; to[2] = from[3]; } else if (sbi->s_bytesex == BYTESEX_LE) { to[0] = from[0]; to[1] = from[1]; to[2] = from[2]; } else { to[0] = from[1]; to[1] = from[2]; to[2] = from[3]; } }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds9469.12%116.67%
Linus Torvalds (pre-git)3626.47%466.67%
Christoph Hellwig64.41%116.67%
Total136100.00%6100.00%

static const struct inode_operations sysv_symlink_inode_operations = { .get_link = page_get_link, .getattr = sysv_getattr, };
void sysv_set_inode(struct inode *inode, dev_t rdev) { if (S_ISREG(inode->i_mode)) { inode->i_op = &sysv_file_inode_operations; inode->i_fop = &sysv_file_operations; inode->i_mapping->a_ops = &sysv_aops; } else if (S_ISDIR(inode->i_mode)) { inode->i_op = &sysv_dir_inode_operations; inode->i_fop = &sysv_dir_operations; inode->i_mapping->a_ops = &sysv_aops; } else if (S_ISLNK(inode->i_mode)) { inode->i_op = &sysv_symlink_inode_operations; inode_nohighmem(inode); inode->i_mapping->a_ops = &sysv_aops; } else init_special_inode(inode, inode->i_mode, rdev); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds12296.06%150.00%
Al Viro53.94%150.00%
Total127100.00%2100.00%


struct inode *sysv_iget(struct super_block *sb, unsigned int ino) { struct sysv_sb_info * sbi = SYSV_SB(sb); struct buffer_head * bh; struct sysv_inode * raw_inode; struct sysv_inode_info * si; struct inode *inode; unsigned int block; if (!ino || ino > sbi->s_ninodes) { printk("Bad inode number on dev %s: %d is out of range\n", sb->s_id, ino); return ERR_PTR(-EIO); } inode = iget_locked(sb, ino); if (!inode) return ERR_PTR(-ENOMEM); if (!(inode->i_state & I_NEW)) return inode; raw_inode = sysv_raw_inode(sb, ino, &bh); if (!raw_inode) { printk("Major problem: unable to read inode from dev %s\n", inode->i_sb->s_id); goto bad_inode; } /* SystemV FS: kludge permissions if ino==SYSV_ROOT_INO ?? */ inode->i_mode = fs16_to_cpu(sbi, raw_inode->i_mode); i_uid_write(inode, (uid_t)fs16_to_cpu(sbi, raw_inode->i_uid)); i_gid_write(inode, (gid_t)fs16_to_cpu(sbi, raw_inode->i_gid)); set_nlink(inode, fs16_to_cpu(sbi, raw_inode->i_nlink)); inode->i_size = fs32_to_cpu(sbi, raw_inode->i_size); inode->i_atime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_atime); inode->i_mtime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_mtime); inode->i_ctime.tv_sec = fs32_to_cpu(sbi, raw_inode->i_ctime); inode->i_ctime.tv_nsec = 0; inode->i_atime.tv_nsec = 0; inode->i_mtime.tv_nsec = 0; inode->i_blocks = 0; si = SYSV_I(inode); for (block = 0; block < 10+1+1+1; block++) read3byte(sbi, &raw_inode->i_data[3*block], (u8 *)&si->i_data[block]); brelse(bh); si->i_dir_start_lookup = 0; if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) sysv_set_inode(inode, old_decode_dev(fs32_to_cpu(sbi, si->i_data[0]))); else sysv_set_inode(inode, 0); unlock_new_inode(inode); return inode; bad_inode: iget_failed(inode); return ERR_PTR(-EIO); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)17741.26%529.41%
Linus Torvalds9722.61%529.41%
David Howells7216.78%15.88%
Andi Kleen306.99%15.88%
Christoph Hellwig245.59%211.76%
Al Viro173.96%15.88%
Eric W. Biedermann81.86%15.88%
Miklos Szeredi40.93%15.88%
Total429100.00%17100.00%


static int __sysv_write_inode(struct inode *inode, int wait) { struct super_block * sb = inode->i_sb; struct sysv_sb_info * sbi = SYSV_SB(sb); struct buffer_head * bh; struct sysv_inode * raw_inode; struct sysv_inode_info * si; unsigned int ino, block; int err = 0; ino = inode->i_ino; if (!ino || ino > sbi->s_ninodes) { printk("Bad inode number on dev %s: %d is out of range\n", inode->i_sb->s_id, ino); return -EIO; } raw_inode = sysv_raw_inode(sb, ino, &bh); if (!raw_inode) { printk("unable to read i-node block\n"); return -EIO; } raw_inode->i_mode = cpu_to_fs16(sbi, inode->i_mode); raw_inode->i_uid = cpu_to_fs16(sbi, fs_high2lowuid(i_uid_read(inode))); raw_inode->i_gid = cpu_to_fs16(sbi, fs_high2lowgid(i_gid_read(inode))); raw_inode->i_nlink = cpu_to_fs16(sbi, inode->i_nlink); raw_inode->i_size = cpu_to_fs32(sbi, inode->i_size); raw_inode->i_atime = cpu_to_fs32(sbi, inode->i_atime.tv_sec); raw_inode->i_mtime = cpu_to_fs32(sbi, inode->i_mtime.tv_sec); raw_inode->i_ctime = cpu_to_fs32(sbi, inode->i_ctime.tv_sec); si = SYSV_I(inode); if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) si->i_data[0] = cpu_to_fs32(sbi, old_encode_dev(inode->i_rdev)); for (block = 0; block < 10+1+1+1; block++) write3byte(sbi, (u8 *)&si->i_data[block], &raw_inode->i_data[3*block]); mark_buffer_dirty(bh); if (wait) { sync_dirty_buffer(bh); if (buffer_req(bh) && !buffer_uptodate(bh)) { printk ("IO error syncing sysv inode [%s:%08x]\n", sb->s_id, ino); err = -EIO; } } brelse(bh); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds (pre-git)24964.84%425.00%
Linus Torvalds7018.23%425.00%
Al Viro266.77%212.50%
Christoph Hellwig266.77%318.75%
Eric W. Biedermann61.56%16.25%
Andi Kleen61.56%16.25%
Andrew Morton10.26%16.25%
Total384100.00%16100.00%


int sysv_write_inode(struct inode *inode, struct writeback_control *wbc) { return __sysv_write_inode(inode, wbc->sync_mode == WB_SYNC_ALL); }

Contributors

PersonTokensPropCommitsCommitProp
Christoph Hellwig27100.00%1100.00%
Total27100.00%1100.00%


int sysv_sync_inode(struct inode *inode) { return __sysv_write_inode(inode, 1); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro1583.33%133.33%
Linus Torvalds (pre-git)211.11%133.33%
Christoph Hellwig15.56%133.33%
Total18100.00%3100.00%


static void sysv_evict_inode(struct inode *inode) { truncate_inode_pages_final(&inode->i_data); if (!inode->i_nlink) { inode->i_size = 0; sysv_truncate(inode); } invalidate_inode_buffers(inode); clear_inode(inode); if (!inode->i_nlink) sysv_free_inode(inode); }

Contributors

PersonTokensPropCommitsCommitProp
Al Viro2642.62%114.29%
Linus Torvalds1626.23%114.29%
Linus Torvalds (pre-git)1016.39%228.57%
Mark Fasheh711.48%114.29%
Johannes Weiner11.64%114.29%
Jan Kara11.64%114.29%
Total61100.00%7100.00%

static struct kmem_cache *sysv_inode_cachep;
static struct inode *sysv_alloc_inode(struct super_block *sb) { struct sysv_inode_info *si; si = kmem_cache_alloc(sysv_inode_cachep, GFP_KERNEL); if (!si) return NULL; return &si->vfs_inode; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds4097.56%150.00%
Christoph Lameter12.44%150.00%
Total41100.00%2100.00%


static void sysv_i_callback(struct rcu_head *head) { struct inode *inode = container_of(head, struct inode, i_rcu); kmem_cache_free(sysv_inode_cachep, SYSV_I(inode)); }

Contributors

PersonTokensPropCommitsCommitProp
Nicholas Piggin1850.00%150.00%
Linus Torvalds1850.00%150.00%
Total36100.00%2100.00%


static void sysv_destroy_inode(struct inode *inode) { call_rcu(&inode->i_rcu, sysv_i_callback); }

Contributors

PersonTokensPropCommitsCommitProp
Nicholas Piggin21100.00%1100.00%
Total21100.00%1100.00%


static void init_once(void *p) { struct sysv_inode_info *si = (struct sysv_inode_info *)p; inode_init_once(&si->vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds2790.00%150.00%
Christoph Lameter310.00%150.00%
Total30100.00%2100.00%

const struct super_operations sysv_sops = { .alloc_inode = sysv_alloc_inode, .destroy_inode = sysv_destroy_inode, .write_inode = sysv_write_inode, .evict_inode = sysv_evict_inode, .put_super = sysv_put_super, .sync_fs = sysv_sync_fs, .remount_fs = sysv_remount, .statfs = sysv_statfs, };
int __init sysv_init_icache(void) { sysv_inode_cachep = kmem_cache_create("sysv_inode_cache", sizeof(struct sysv_inode_info), 0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT, init_once); if (!sysv_inode_cachep) return -ENOMEM; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds3888.37%125.00%
Paul Jackson24.65%125.00%
Vladimir Davydov24.65%125.00%
Andrew Morton12.33%125.00%
Total43100.00%4100.00%


void sysv_destroy_icache(void) { /* * Make sure all delayed rcu free inodes are flushed before we * destroy cache. */ rcu_barrier(); kmem_cache_destroy(sysv_inode_cachep); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds1275.00%150.00%
Kirill A. Shutemov425.00%150.00%
Total16100.00%2100.00%


Overall Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds79939.40%710.94%
Linus Torvalds (pre-git)59929.54%1523.44%
Christoph Hellwig2029.96%914.06%
Al Viro1457.15%812.50%
David Howells834.09%23.12%
Coly Li442.17%11.56%
Nicholas Piggin391.92%11.56%
Andi Kleen381.87%11.56%
Art Haas150.74%11.56%
Eric W. Biedermann140.69%11.56%
Marco Stornelli100.49%11.56%
Mark Fasheh70.35%11.56%
Christoph Lameter60.30%34.69%
Theodore Y. Ts'o50.25%11.56%
Miklos Szeredi40.20%11.56%
Kirill A. Shutemov40.20%11.56%
Andrew Morton30.15%34.69%
Duane Griffin30.15%11.56%
Paul Jackson20.10%11.56%
Vladimir Davydov20.10%11.56%
Arjan van de Ven10.05%11.56%
Johannes Weiner10.05%11.56%
Jan Kara10.05%11.56%
Josef 'Jeff' Sipek10.05%11.56%
Total2028100.00%64100.00%
Directory: fs/sysv
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.