5 * Inode allocation handling routines for the OSTA-UDF(tm) filesystem.
8 * This file is distributed under the terms of the GNU General Public
9 * License (GPL). Copies of the GPL can be obtained from:
10 * ftp://prep.ai.mit.edu/pub/gnu/GPL
11 * Each contributing author retains all rights to their own work.
13 * (C) 1998-2001 Ben Fennema
17 * 02/24/99 blf Created.
23 #include <linux/quotaops.h>
24 #include <linux/udf_fs.h>
25 #include <linux/sched.h>
26 #include <linux/slab.h>
31 void udf_free_inode(struct inode *inode)
33 struct super_block *sb = inode->i_sb;
34 struct udf_sb_info *sbi = UDF_SB(sb);
37 * Note: we must free any quota before locking the superblock,
38 * as writing the quota to disk may need the lock as well.
40 DQUOT_FREE_INODE(inode);
45 mutex_lock(&sbi->s_alloc_mutex);
47 struct logicalVolIntegrityDescImpUse *lvidiu =
49 if (S_ISDIR(inode->i_mode))
51 cpu_to_le32(le32_to_cpu(lvidiu->numDirs) - 1);
54 cpu_to_le32(le32_to_cpu(lvidiu->numFiles) - 1);
56 mark_buffer_dirty(sbi->s_lvid_bh);
58 mutex_unlock(&sbi->s_alloc_mutex);
60 udf_free_blocks(sb, NULL, UDF_I_LOCATION(inode), 0, 1);
63 struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
65 struct super_block *sb = dir->i_sb;
66 struct udf_sb_info *sbi = UDF_SB(sb);
69 uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum;
71 inode = new_inode(sb);
79 UDF_I_UNIQUE(inode) = 0;
80 UDF_I_LENEXTENTS(inode) = 0;
81 UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
82 UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
83 UDF_I_STRAT4096(inode) = 0;
85 block = udf_new_block(dir->i_sb, NULL,
86 UDF_I_LOCATION(dir).partitionReferenceNum,
93 mutex_lock(&sbi->s_alloc_mutex);
95 struct logicalVolIntegrityDesc *lvid =
96 (struct logicalVolIntegrityDesc *)
97 sbi->s_lvid_bh->b_data;
98 struct logicalVolIntegrityDescImpUse *lvidiu =
100 struct logicalVolHeaderDesc *lvhd;
102 lvhd = (struct logicalVolHeaderDesc *)
103 (lvid->logicalVolContentsUse);
106 cpu_to_le32(le32_to_cpu(lvidiu->numDirs) + 1);
109 cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1);
110 UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
111 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
113 lvhd->uniqueID = cpu_to_le64(uniqueID);
114 mark_buffer_dirty(sbi->s_lvid_bh);
116 inode->i_mode = mode;
117 inode->i_uid = current->fsuid;
118 if (dir->i_mode & S_ISGID) {
119 inode->i_gid = dir->i_gid;
123 inode->i_gid = current->fsgid;
126 UDF_I_LOCATION(inode).logicalBlockNum = block;
127 UDF_I_LOCATION(inode).partitionReferenceNum =
128 UDF_I_LOCATION(dir).partitionReferenceNum;
129 inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
131 UDF_I_LENEATTR(inode) = 0;
132 UDF_I_LENALLOC(inode) = 0;
133 UDF_I_USE(inode) = 0;
134 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
135 UDF_I_EFE(inode) = 1;
136 if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
137 sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
138 UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize -
139 sizeof(struct extendedFileEntry),
142 UDF_I_EFE(inode) = 0;
143 UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize -
144 sizeof(struct fileEntry),
147 if (!UDF_I_DATA(inode)) {
150 mutex_unlock(&sbi->s_alloc_mutex);
153 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
154 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
155 else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
156 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
158 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
159 inode->i_mtime = inode->i_atime = inode->i_ctime =
160 UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
161 insert_inode_hash(inode);
162 mark_inode_dirty(inode);
163 mutex_unlock(&sbi->s_alloc_mutex);
165 if (DQUOT_ALLOC_INODE(inode)) {
167 inode->i_flags |= S_NOQUOTA;