static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err;
inode_inc_link_count(dir);
inode = minix_new_inode(dir, S_IFDIR | mode, &err);
if (!inode)
goto out_dir;
minix_set_inode(inode, 0);
inode_inc_link_count(inode);
err = minix_make_empty(inode, dir);
if (err)
goto out_fail;
err = minix_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput(inode);
out_dir:
inode_dec_link_count(dir);
goto out;
}
static int nilfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
struct inode *inode;
struct nilfs_transaction_info ti;
int err;
if (dir->i_nlink >= NILFS_LINK_MAX)
return -EMLINK;
err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
if (err)
return err;
inode_inc_link_count(dir);
inode = nilfs_new_inode(dir, S_IFDIR | mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_dir;
inode->i_op = &nilfs_dir_inode_operations;
inode->i_fop = &nilfs_dir_operations;
inode->i_mapping->a_ops = &nilfs_aops;
inode_inc_link_count(inode);
err = nilfs_make_empty(inode, dir);
if (err)
goto out_fail;
err = nilfs_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
if (!err)
err = nilfs_transaction_commit(dir->i_sb);
else
nilfs_transaction_abort(dir->i_sb);
return err;
out_fail:
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput(inode);
out_dir:
inode_dec_link_count(dir);
goto out;
}
static int replayfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *new_dentry) {
struct inode *inode;
int ret;
replayfs_log_t log;
replayfs_log_inode_t log_inode;
inode = old_dentry->d_inode;
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
ret = replayfs_begin_log_operation(&log);
if (ret) {
goto out;
}
replayfs_log_add_inode(&log, &log_inode, inode);
ret = replayfs_dir_add_nondir(new_dentry, inode, &log, &log_inode);
replayfs_log_inode_done(&log, &log_inode, inode->i_size);
replayfs_end_log_operation(&log);
out:
return ret;
}
static int __tux3_mknod(struct inode *dir, struct dentry *dentry,
struct tux_iattr *iattr, dev_t rdev)
{
struct inode *inode;
int err, is_dir = S_ISDIR(iattr->mode);
if (!huge_valid_dev(rdev))
return -EINVAL;
if (is_dir && dir->i_nlink >= TUX_LINK_MAX)
return -EMLINK;
change_begin(tux_sb(dir->i_sb));
inode = tux_new_inode(dir, iattr, rdev);
err = PTR_ERR(inode);
if (!IS_ERR(inode)) {
err = tux_add_dirent(dir, dentry, inode);
if (!err) {
unlock_new_inode(inode);
if (is_dir)
inode_inc_link_count(dir);
}
}
change_end(tux_sb(dir->i_sb));
return err;
}
static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
struct inode *inode = d_inode(old_dentry);
struct nilfs_transaction_info ti;
int err;
err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
if (err)
return err;
inode->i_ctime = current_time(inode);
inode_inc_link_count(inode);
ihold(inode);
err = nilfs_add_link(dentry, inode);
if (!err) {
d_instantiate(dentry, inode);
err = nilfs_transaction_commit(dir->i_sb);
} else {
inode_dec_link_count(inode);
iput(inode);
nilfs_transaction_abort(dir->i_sb);
}
return err;
}
static int tux3_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
{
struct inode *inode;
int err;
if (!huge_valid_dev(rdev))
return -EINVAL;
change_begin(tux_sb(dir->i_sb));
inode = tux_create_inode(dir, mode, rdev);
err = PTR_ERR(inode);
if (!IS_ERR(inode)) {
err = tux_add_dirent(dir, dentry, inode);
if (!err) {
if ((inode->i_mode & S_IFMT) == S_IFDIR)
inode_inc_link_count(dir);
goto out;
}
clear_nlink(inode);
mark_inode_dirty(inode);
iput(inode);
}
out:
change_end(tux_sb(dir->i_sb));
return err;
}
static int tux3_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
struct inode *inode = old_dentry->d_inode;
struct sb *sb = tux_sb(inode->i_sb);
int err;
if (inode->i_nlink >= TUX_LINK_MAX)
return -EMLINK;
change_begin(sb);
tux3_iattrdirty(inode);
inode->i_ctime = gettime();
inode_inc_link_count(inode);
ihold(inode);
err = tux_add_dirent(dir, dentry, inode);
if (err) {
inode_dec_link_count(inode);
iput(inode);
}
change_end(sb);
return err;
}
static int nilfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
struct nilfs_transaction_info ti;
int err;
if (inode->i_nlink >= NILFS_LINK_MAX)
return -EMLINK;
err = nilfs_transaction_begin(dir->i_sb, &ti, 1);
if (err)
return err;
inode->i_ctime = CURRENT_TIME;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
err = nilfs_add_nondir(dentry, inode);
if (!err)
err = nilfs_transaction_commit(dir->i_sb);
else
nilfs_transaction_abort(dir->i_sb);
return err;
}
static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= UFS_LINK_MAX)
goto out;
dquot_initialize(dir);
lock_kernel();
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_kernel();
d_instantiate(dentry, inode);
out:
return err;
out_fail:
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput (inode);
out_dir:
inode_dec_link_count(dir);
unlock_kernel();
goto out;
}
static int ext2_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
{
struct inode * inode;
int err;
dquot_initialize(dir);
inode_inc_link_count(dir);
inode = ext2_new_inode(dir, S_IFDIR | mode, &dentry->d_name);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_dir;
inode->i_op = &ext2_dir_inode_operations;
inode->i_fop = &ext2_dir_operations;
if (test_opt(inode->i_sb, NOBH))
inode->i_mapping->a_ops = &ext2_nobh_aops;
else
inode->i_mapping->a_ops = &ext2_aops;
inode_inc_link_count(inode);
err = ext2_make_empty(inode, dir);
if (err)
goto out_fail;
err = ext2_add_link(dentry, inode);
if (err)
goto out_fail;
unlock_new_inode(inode);
d_instantiate(dentry, inode);
out:
return err;
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);
goto out;
}
static int ext2_mkdir(struct inode * dir, struct dentry * dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= EXT2_LINK_MAX)
goto out;
inode_inc_link_count(dir);
inode = ext2_new_inode (dir, S_IFDIR | mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_dir;
inode->i_op = &ext2_dir_inode_operations;
inode->i_fop = &ext2_dir_operations;
if (test_opt(inode->i_sb, NOBH))
inode->i_mapping->a_ops = &ext2_nobh_aops;
else
inode->i_mapping->a_ops = &ext2_aops;
inode_inc_link_count(inode);
err = ext2_make_empty(inode, dir);
if (err)
goto out_fail;
err = ext2_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput(inode);
out_dir:
inode_dec_link_count(dir);
goto out;
}
static int ufs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode)
{
struct inode * inode;
int err;
lock_ufs(dir->i_sb);
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_ufs(dir->i_sb);
unlock_new_inode(inode);
d_instantiate(dentry, inode);
out:
return err;
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);
unlock_ufs(dir->i_sb);
goto out;
}
static int minix_link(struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
ihold(inode);
return add_nondir(dentry, inode);
}
static int minix_link(struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = d_inode(old_dentry);
inode->i_ctime = current_time(inode);
inode_inc_link_count(inode);
ihold(inode);
return add_nondir(dentry, inode);
}
static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= minix_sb(dir->i_sb)->s_link_max)
goto out;
inode_inc_link_count(dir);
inode = minix_new_inode(dir, &err);
if (!inode)
goto out_dir;
inode->i_mode = S_IFDIR | mode;
if (dir->i_mode & S_ISGID)
inode->i_mode |= S_ISGID;
minix_set_inode(inode, 0);
inode_inc_link_count(inode);
err = minix_make_empty(inode, dir);
if (err)
goto out_fail;
err = minix_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput(inode);
out_dir:
inode_dec_link_count(dir);
goto out;
}
static int minix_link(struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
if (inode->i_nlink >= minix_sb(inode->i_sb)->s_link_max)
return -EMLINK;
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
return add_nondir(dentry, inode);
}
static int sysv_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= SYSV_SB(dir->i_sb)->s_link_max)
goto out;
inode_inc_link_count(dir);
inode = sysv_new_inode(dir, S_IFDIR|mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_dir;
sysv_set_inode(inode, 0);
inode_inc_link_count(inode);
err = sysv_make_empty(inode, dir);
if (err)
goto out_fail;
err = sysv_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput(inode);
out_dir:
inode_dec_link_count(dir);
goto out;
}
static int sysv_link(struct dentry * old_dentry, struct inode * dir,
struct dentry * dentry)
{
struct inode *inode = old_dentry->d_inode;
if (inode->i_nlink >= SYSV_SB(inode->i_sb)->s_link_max)
return -EMLINK;
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
ihold(inode);
return add_nondir(dentry, inode);
}
static int ext2_link (struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
if (inode->i_nlink >= EXT2_LINK_MAX)
return -EMLINK;
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
return ext2_add_nondir(dentry, inode);
}
static int ufs_link (struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
int error;
lock_ufs(dir->i_sb);
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
ihold(inode);
error = ufs_add_nondir(dentry, inode);
unlock_ufs(dir->i_sb);
return error;
}
static int simplefs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) {
struct inode *inode = old_dentry->d_inode;
int err;
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
err = simplefs_insert_dentry(dentry, inode);
if (!err) {
d_instantiate(dentry, inode);
return 0;
}
inode_dec_link_count(inode);
iput(inode);
return err;
}
// ln A/B C/D
// Here, old_dentry points to B
// dir points to C
static int ext2_link (struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
if (inode->i_nlink >= EXT2_LINK_MAX)
return -EMLINK;
ext2bp_debug("Linking with old inode: %d\n", inode->i_ino);
ext2bp_debug("Linking new dir: %d\n", dir->i_ino);
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
return ext2_add_nondir(dentry, inode);
}
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_SEC;
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;
}
static int ufs_link (struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
int error;
lock_kernel();
if (inode->i_nlink >= UFS_LINK_MAX) {
unlock_kernel();
return -EMLINK;
}
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
error = ufs_add_nondir(dentry, inode);
unlock_kernel();
return error;
}
static int ext2_link (struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
int err;
dquot_initialize(dir);
inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count(inode);
ihold(inode);
err = ext2_add_link(dentry, inode);
if (!err) {
d_instantiate(dentry, inode);
return 0;
}
inode_dec_link_count(inode);
iput(inode);
return err;
}
static int tux3_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
int err;
if (inode->i_nlink >= TUX_LINK_MAX)
return -EMLINK;
change_begin(tux_sb(inode->i_sb));
inode->i_ctime = gettime();
inode_inc_link_count(inode);
atomic_inc(&inode->i_count);
err = tux_add_dirent(dir, dentry, inode);
if (err) {
inode_dec_link_count(inode);
iput(inode);
}
change_end(tux_sb(inode->i_sb));
return err;
}
static int simplefs_mkdir(struct inode *dir, struct dentry *dentry, int mode) {
struct inode *inode = NULL;
long ino;
int err = 0;
printk(KERN_INFO "simplefs_mkdir: %s %d\n", dentry->d_name.name, mode);
inode_inc_link_count(dir);
ino = bitmap_alloc_inode(dir->i_sb);
if (ino < 0)
return -EIO;
inode = simplefs_iget(dir->i_sb, ino);
if (IS_ERR(inode))
return -EIO;
// set inode operations
inode->i_op = &simplefs_file_inode_operations;
inode->i_fop = &simplefs_file_operations;
inode->i_mapping->a_ops = &simplefs_aops;
inode->i_mode = mode | S_IFDIR;
inode->i_nlink = 2;
inode->i_size = inode->i_blocks = inode->i_bytes = 0;
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
mark_inode_dirty(inode);
err = simplefs_insert_dentry(dentry, inode);
if (!err) {
d_instantiate(dentry, inode);
return 0;
}
inode_dec_link_count(inode);
inode_dec_link_count(inode);
iput(inode);
inode_dec_link_count(dir);
return err;
}
static int __tux3_mknod(struct inode *dir, struct dentry *dentry,
struct tux_iattr *iattr, dev_t rdev)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
struct inode *inode;
int err, is_dir = S_ISDIR(iattr->mode);
if (!huge_valid_dev(rdev))
return -EINVAL;
if (is_dir && dir->i_nlink >= TUX_LINK_MAX)
return -EMLINK;
change_begin(tux_sb(dir->i_sb));
inode = tux_create_inode(dir, iattr, rdev);
err = PTR_ERR(inode);
if (!IS_ERR(inode)) {
err = tux_add_dirent(dir, dentry, inode);
if (!err) {
unlock_new_inode(inode);
if (is_dir)
inode_inc_link_count(dir);
goto out;
}
clear_nlink(inode);
tux3_mark_inode_dirty(inode);
unlock_new_inode(inode);
iput(inode);
}
out:
change_end(tux_sb(dir->i_sb));
return err;
}
/*
==================================================================================
Function :me2fsLink
Input :struct dentry *old_dentry
< old file name >
struct inode *dir
< vfs inode of parent >
struct dentry *dentry
< new file name >
Output :void
Return :int
< result >
Description :link old file to new file
==================================================================================
*/
static int
me2fsLink( struct dentry *old_dentry, struct inode *dir, struct dentry *dentry )
{
struct inode *old_inode;
int err;
old_inode = old_dentry->d_inode;
old_inode->i_ctime = CURRENT_TIME_SEC;
inode_inc_link_count( old_inode );
ihold( old_inode );
if( !( err = me2fsAddLink( dentry, old_inode ) ) )
{
d_instantiate( dentry, old_inode );
return( 0 );
}
inode_dec_link_count( old_inode );
iput( old_inode );
return( err );
}
int uxfs_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
{
struct uxfs_inode *nip;
struct buffer_head *bh;
struct super_block *sb = dip->i_sb;
struct uxfs_dirent *dirent;
struct inode *inode;
ino_t inum = 0;
int blk;
/*
* Make sure there isn't already an entry. If not,
* allocate one, a new inode and new incore inode.
*/
inum = uxfs_find_entry(dip, (char *)dentry->d_name.name);
if (inum)
return -EEXIST;
inode = new_inode(sb);
if (!inode)
return -ENOSPC;
inum = uxfs_ialloc(sb);
if (!inum) {
iput(inode);
return -ENOSPC;
}
uxfs_diradd(dip, (char *)dentry->d_name.name, inum);
inode->i_uid = current_fsuid();
inode->i_gid =
(dip->i_mode & S_ISGID) ? dip->i_gid : current_fsgid();
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
inode->i_blocks = 1;
// inode->i_blksize = UXFS_BSIZE;
inode->i_op = &uxfs_dir_inops;
inode->i_fop = &uxfs_dir_operations;
inode->i_mapping->a_ops = &uxfs_aops;
inode->i_mode = mode | S_IFDIR;
inode->i_ino = inum;
inode->i_size = UXFS_BSIZE;
inode->i_private = uxfs_i(inode); //initialize private, again!
set_nlink(inode, 2);
nip = (struct uxfs_inode *)inode->i_private;
nip->i_mode = mode | S_IFDIR;
nip->i_nlink = 2;
nip->i_atime = nip->i_ctime = nip->i_mtime = CURRENT_TIME.tv_sec;
nip->i_uid = current_fsuid();
nip->i_gid =
(dip->i_mode & S_ISGID) ? dip->i_gid : current_fsgid();
nip->i_size = 512;
nip->i_blocks = 1;
memset(nip->i_addr, 0,
UXFS_DIRECT_BLOCKS * sizeof(nip->i_addr[0]));
blk = uxfs_block_alloc(sb);
nip->i_addr[0] = blk;
bh = sb_bread(sb, blk);
memset(bh->b_data, 0, UXFS_BSIZE);
dirent = (struct uxfs_dirent *)bh->b_data;
dirent->d_ino = inum;
strcpy(dirent->d_name, ".");
dirent++;
dirent->d_ino = inode->i_ino;
strcpy(dirent->d_name, "..");
mark_buffer_dirty(bh);
brelse(bh);
insert_inode_hash(inode);
d_instantiate(dentry, inode);
mark_inode_dirty(inode);
/*
* Increment the link count of the parent directory.
*/
inode_inc_link_count(dip);
mark_inode_dirty(dip);
return 0;
}
