Linux Audio

Check our new training course

Linux kernel drivers training

Mar 31-Apr 9, 2025, special US time zones
Register
Loading...
v4.17
 
  1/*
  2 *   Copyright (C) International Business Machines Corp., 2000-2004
  3 *
  4 *   This program is free software;  you can redistribute it and/or modify
  5 *   it under the terms of the GNU General Public License as published by
  6 *   the Free Software Foundation; either version 2 of the License, or
  7 *   (at your option) any later version.
  8 *
  9 *   This program is distributed in the hope that it will be useful,
 10 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 11 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 12 *   the GNU General Public License for more details.
 13 *
 14 *   You should have received a copy of the GNU General Public License
 15 *   along with this program;  if not, write to the Free Software
 16 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 17 */
 18
 19#include <linux/fs.h>
 20#include <linux/quotaops.h>
 21#include "jfs_incore.h"
 22#include "jfs_inode.h"
 23#include "jfs_filsys.h"
 24#include "jfs_imap.h"
 25#include "jfs_dinode.h"
 26#include "jfs_debug.h"
 27
 28
 29void jfs_set_inode_flags(struct inode *inode)
 30{
 31	unsigned int flags = JFS_IP(inode)->mode2;
 32	unsigned int new_fl = 0;
 33
 34	if (flags & JFS_IMMUTABLE_FL)
 35		new_fl |= S_IMMUTABLE;
 36	if (flags & JFS_APPEND_FL)
 37		new_fl |= S_APPEND;
 38	if (flags & JFS_NOATIME_FL)
 39		new_fl |= S_NOATIME;
 40	if (flags & JFS_DIRSYNC_FL)
 41		new_fl |= S_DIRSYNC;
 42	if (flags & JFS_SYNC_FL)
 43		new_fl |= S_SYNC;
 44	inode_set_flags(inode, new_fl, S_IMMUTABLE | S_APPEND | S_NOATIME |
 45			S_DIRSYNC | S_SYNC);
 46}
 47
 48/*
 49 * NAME:	ialloc()
 50 *
 51 * FUNCTION:	Allocate a new inode
 52 *
 53 */
 54struct inode *ialloc(struct inode *parent, umode_t mode)
 55{
 56	struct super_block *sb = parent->i_sb;
 57	struct inode *inode;
 58	struct jfs_inode_info *jfs_inode;
 59	int rc;
 60
 61	inode = new_inode(sb);
 62	if (!inode) {
 63		jfs_warn("ialloc: new_inode returned NULL!");
 64		rc = -ENOMEM;
 65		goto fail;
 66	}
 67
 68	jfs_inode = JFS_IP(inode);
 69
 70	rc = diAlloc(parent, S_ISDIR(mode), inode);
 71	if (rc) {
 72		jfs_warn("ialloc: diAlloc returned %d!", rc);
 73		if (rc == -EIO)
 74			make_bad_inode(inode);
 75		goto fail_put;
 76	}
 77
 78	if (insert_inode_locked(inode) < 0) {
 79		rc = -EINVAL;
 80		goto fail_put;
 81	}
 82
 83	inode_init_owner(inode, parent, mode);
 84	/*
 85	 * New inodes need to save sane values on disk when
 86	 * uid & gid mount options are used
 87	 */
 88	jfs_inode->saved_uid = inode->i_uid;
 89	jfs_inode->saved_gid = inode->i_gid;
 90
 91	/*
 92	 * Allocate inode to quota.
 93	 */
 94	rc = dquot_initialize(inode);
 95	if (rc)
 96		goto fail_drop;
 97	rc = dquot_alloc_inode(inode);
 98	if (rc)
 99		goto fail_drop;
100
101	/* inherit flags from parent */
102	jfs_inode->mode2 = JFS_IP(parent)->mode2 & JFS_FL_INHERIT;
103
104	if (S_ISDIR(mode)) {
105		jfs_inode->mode2 |= IDIRECTORY;
106		jfs_inode->mode2 &= ~JFS_DIRSYNC_FL;
107	}
108	else {
109		jfs_inode->mode2 |= INLINEEA | ISPARSE;
110		if (S_ISLNK(mode))
111			jfs_inode->mode2 &= ~(JFS_IMMUTABLE_FL|JFS_APPEND_FL);
112	}
113	jfs_inode->mode2 |= inode->i_mode;
114
115	inode->i_blocks = 0;
116	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
117	jfs_inode->otime = inode->i_ctime.tv_sec;
118	inode->i_generation = JFS_SBI(sb)->gengen++;
119
120	jfs_inode->cflag = 0;
121
122	/* Zero remaining fields */
123	memset(&jfs_inode->acl, 0, sizeof(dxd_t));
124	memset(&jfs_inode->ea, 0, sizeof(dxd_t));
125	jfs_inode->next_index = 0;
126	jfs_inode->acltype = 0;
127	jfs_inode->btorder = 0;
128	jfs_inode->btindex = 0;
129	jfs_inode->bxflag = 0;
130	jfs_inode->blid = 0;
131	jfs_inode->atlhead = 0;
132	jfs_inode->atltail = 0;
133	jfs_inode->xtlid = 0;
134	jfs_set_inode_flags(inode);
135
136	jfs_info("ialloc returns inode = 0x%p", inode);
137
138	return inode;
139
140fail_drop:
141	dquot_drop(inode);
142	inode->i_flags |= S_NOQUOTA;
143	clear_nlink(inode);
144	unlock_new_inode(inode);
 
 
145fail_put:
146	iput(inode);
147fail:
148	return ERR_PTR(rc);
149}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *   Copyright (C) International Business Machines Corp., 2000-2004
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  4 */
  5
  6#include <linux/fs.h>
  7#include <linux/quotaops.h>
  8#include "jfs_incore.h"
  9#include "jfs_inode.h"
 10#include "jfs_filsys.h"
 11#include "jfs_imap.h"
 12#include "jfs_dinode.h"
 13#include "jfs_debug.h"
 14
 15
 16void jfs_set_inode_flags(struct inode *inode)
 17{
 18	unsigned int flags = JFS_IP(inode)->mode2;
 19	unsigned int new_fl = 0;
 20
 21	if (flags & JFS_IMMUTABLE_FL)
 22		new_fl |= S_IMMUTABLE;
 23	if (flags & JFS_APPEND_FL)
 24		new_fl |= S_APPEND;
 25	if (flags & JFS_NOATIME_FL)
 26		new_fl |= S_NOATIME;
 27	if (flags & JFS_DIRSYNC_FL)
 28		new_fl |= S_DIRSYNC;
 29	if (flags & JFS_SYNC_FL)
 30		new_fl |= S_SYNC;
 31	inode_set_flags(inode, new_fl, S_IMMUTABLE | S_APPEND | S_NOATIME |
 32			S_DIRSYNC | S_SYNC);
 33}
 34
 35/*
 36 * NAME:	ialloc()
 37 *
 38 * FUNCTION:	Allocate a new inode
 39 *
 40 */
 41struct inode *ialloc(struct inode *parent, umode_t mode)
 42{
 43	struct super_block *sb = parent->i_sb;
 44	struct inode *inode;
 45	struct jfs_inode_info *jfs_inode;
 46	int rc;
 47
 48	inode = new_inode(sb);
 49	if (!inode) {
 50		jfs_warn("ialloc: new_inode returned NULL!");
 51		return ERR_PTR(-ENOMEM);
 
 52	}
 53
 54	jfs_inode = JFS_IP(inode);
 55
 56	rc = diAlloc(parent, S_ISDIR(mode), inode);
 57	if (rc) {
 58		jfs_warn("ialloc: diAlloc returned %d!", rc);
 
 
 59		goto fail_put;
 60	}
 61
 62	if (insert_inode_locked(inode) < 0) {
 63		rc = -EINVAL;
 64		goto fail_put;
 65	}
 66
 67	inode_init_owner(&nop_mnt_idmap, inode, parent, mode);
 68	/*
 69	 * New inodes need to save sane values on disk when
 70	 * uid & gid mount options are used
 71	 */
 72	jfs_inode->saved_uid = inode->i_uid;
 73	jfs_inode->saved_gid = inode->i_gid;
 74
 75	/*
 76	 * Allocate inode to quota.
 77	 */
 78	rc = dquot_initialize(inode);
 79	if (rc)
 80		goto fail_drop;
 81	rc = dquot_alloc_inode(inode);
 82	if (rc)
 83		goto fail_drop;
 84
 85	/* inherit flags from parent */
 86	jfs_inode->mode2 = JFS_IP(parent)->mode2 & JFS_FL_INHERIT;
 87
 88	if (S_ISDIR(mode)) {
 89		jfs_inode->mode2 |= IDIRECTORY;
 90		jfs_inode->mode2 &= ~JFS_DIRSYNC_FL;
 91	}
 92	else {
 93		jfs_inode->mode2 |= INLINEEA | ISPARSE;
 94		if (S_ISLNK(mode))
 95			jfs_inode->mode2 &= ~(JFS_IMMUTABLE_FL|JFS_APPEND_FL);
 96	}
 97	jfs_inode->mode2 |= inode->i_mode;
 98
 99	inode->i_blocks = 0;
100	simple_inode_init_ts(inode);
101	jfs_inode->otime = inode_get_ctime_sec(inode);
102	inode->i_generation = JFS_SBI(sb)->gengen++;
103
104	jfs_inode->cflag = 0;
105
106	/* Zero remaining fields */
107	memset(&jfs_inode->acl, 0, sizeof(dxd_t));
108	memset(&jfs_inode->ea, 0, sizeof(dxd_t));
109	jfs_inode->next_index = 0;
110	jfs_inode->acltype = 0;
111	jfs_inode->btorder = 0;
112	jfs_inode->btindex = 0;
113	jfs_inode->bxflag = 0;
114	jfs_inode->blid = 0;
115	jfs_inode->atlhead = 0;
116	jfs_inode->atltail = 0;
117	jfs_inode->xtlid = 0;
118	jfs_set_inode_flags(inode);
119
120	jfs_info("ialloc returns inode = 0x%p", inode);
121
122	return inode;
123
124fail_drop:
125	dquot_drop(inode);
126	inode->i_flags |= S_NOQUOTA;
127	clear_nlink(inode);
128	discard_new_inode(inode);
129	return ERR_PTR(rc);
130
131fail_put:
132	iput(inode);
 
133	return ERR_PTR(rc);
134}