2 * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
6 * Copyright (c) 2012 Martin Sucha
7 * Copyright (c) 2012 Frantisek Princ
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
14 * - Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * - Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * - The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 /** @addtogroup lwext4
39 * @brief Inode handle functions
42 #include "ext4_config.h"
43 #include "ext4_types.h"
44 #include "ext4_inode.h"
45 #include "ext4_super.h"
47 /**@brief Compute number of bits for block count.
48 * @param block_size Filesystem block_size
49 * @return Number of bits
51 static uint32_t ext4_inode_block_bits_count(uint32_t block_size)
54 uint32_t size = block_size;
64 uint32_t ext4_inode_get_mode(struct ext4_sblock *sb, struct ext4_inode *inode)
66 uint32_t v = to_le16(inode->mode);
68 if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_HURD) {
69 v |= ((uint32_t)to_le16(inode->osd2.hurd2.mode_high)) << 16;
75 void ext4_inode_set_mode(struct ext4_sblock *sb, struct ext4_inode *inode,
78 inode->mode = to_le16((mode << 16) >> 16);
80 if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_HURD)
81 inode->osd2.hurd2.mode_high = to_le16(mode >> 16);
84 uint32_t ext4_inode_get_uid(struct ext4_inode *inode)
86 return to_le32(inode->uid);
89 void ext4_inode_set_uid(struct ext4_inode *inode, uint32_t uid)
91 inode->uid = to_le32(uid);
94 uint64_t ext4_inode_get_size(struct ext4_sblock *sb, struct ext4_inode *inode)
96 uint64_t v = to_le32(inode->size_lo);
98 if ((ext4_get32(sb, rev_level) > 0) &&
99 (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)))
100 v |= ((uint64_t)to_le32(inode->size_hi)) << 32;
105 void ext4_inode_set_size(struct ext4_inode *inode, uint64_t size)
107 inode->size_lo = to_le32((size << 32) >> 32);
108 inode->size_hi = to_le32(size >> 32);
112 ext4_inode_get_checksum(struct ext4_sblock *sb, struct ext4_inode *inode)
114 uint16_t inode_size = ext4_get16(sb, inode_size);
115 uint32_t v = to_le16(inode->osd2.linux2.checksum_lo);
117 if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
118 v |= ((uint32_t)to_le16(inode->checksum_hi)) << 16;
124 ext4_inode_set_checksum(struct ext4_sblock *sb, struct ext4_inode *inode,
127 uint16_t inode_size = ext4_get16(sb, inode_size);
128 inode->osd2.linux2.checksum_lo =
129 to_le16((checksum << 16) >> 16);
131 if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
132 inode->checksum_hi = to_le16(checksum >> 16);
136 uint32_t ext4_inode_get_access_time(struct ext4_inode *inode)
138 return to_le32(inode->access_time);
140 void ext4_inode_set_access_time(struct ext4_inode *inode, uint32_t time)
142 inode->access_time = to_le32(time);
145 uint32_t ext4_inode_get_change_inode_time(struct ext4_inode *inode)
147 return to_le32(inode->change_inode_time);
149 void ext4_inode_set_change_inode_time(struct ext4_inode *inode, uint32_t time)
151 inode->change_inode_time = to_le32(time);
154 uint32_t ext4_inode_get_modification_time(struct ext4_inode *inode)
156 return to_le32(inode->modification_time);
159 void ext4_inode_set_modification_time(struct ext4_inode *inode, uint32_t time)
161 inode->modification_time = to_le32(time);
164 uint32_t ext4_inode_get_deletion_time(struct ext4_inode *inode)
166 return to_le32(inode->deletion_time);
169 void ext4_inode_set_deletion_time(struct ext4_inode *inode, uint32_t time)
171 inode->deletion_time = to_le32(time);
174 uint32_t ext4_inode_get_gid(struct ext4_inode *inode)
176 return to_le32(inode->gid);
178 void ext4_inode_set_gid(struct ext4_inode *inode, uint32_t gid)
180 inode->gid = to_le32(gid);
183 uint16_t ext4_inode_get_links_count(struct ext4_inode *inode)
185 return to_le16(inode->links_count);
187 void ext4_inode_set_links_count(struct ext4_inode *inode, uint16_t cnt)
189 inode->links_count = to_le16(cnt);
192 uint64_t ext4_inode_get_blocks_count(struct ext4_sblock *sb,
193 struct ext4_inode *inode)
195 uint64_t count = to_le32(inode->blocks_count_lo);
197 if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_HUGE_FILE)) {
200 count |= ((uint64_t)to_le16(inode->osd2.linux2.blocks_high))
203 if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_HUGE_FILE)) {
205 uint32_t block_bits = ext4_inode_block_bits_count(
206 ext4_sb_get_block_size(sb));
207 return count << (block_bits - 9);
214 int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
215 struct ext4_inode *inode, uint64_t count)
222 inode->blocks_count_lo = to_le32(count);
223 inode->osd2.linux2.blocks_high = 0;
224 ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
229 /* Check if there can be used huge files (many blocks) */
230 if (!ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_HUGE_FILE))
238 inode->blocks_count_lo = to_le32(count);
239 inode->osd2.linux2.blocks_high = to_le16(count >> 32);
240 ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
242 uint32_t block_bits =
243 ext4_inode_block_bits_count(ext4_sb_get_block_size(sb));
245 ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
246 count = count >> (block_bits - 9);
247 inode->blocks_count_lo = to_le32(count);
248 inode->osd2.linux2.blocks_high = to_le16(count >> 32);
254 uint32_t ext4_inode_get_flags(struct ext4_inode *inode)
256 return to_le32(inode->flags);
258 void ext4_inode_set_flags(struct ext4_inode *inode, uint32_t flags)
260 inode->flags = to_le32(flags);
263 uint32_t ext4_inode_get_generation(struct ext4_inode *inode)
265 return to_le32(inode->generation);
267 void ext4_inode_set_generation(struct ext4_inode *inode, uint32_t gen)
269 inode->generation = to_le32(gen);
272 uint16_t ext4_inode_get_extra_isize(struct ext4_inode *inode)
274 return to_le16(inode->extra_isize);
277 void ext4_inode_set_extra_isize(struct ext4_inode *inode, uint16_t size)
279 inode->extra_isize = to_le16(size);
282 uint64_t ext4_inode_get_file_acl(struct ext4_inode *inode,
283 struct ext4_sblock *sb)
286 uint64_t v = to_le32(inode->file_acl_lo);
288 if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
289 v |= ((uint32_t)to_le16(inode->osd2.linux2.file_acl_high))
295 void ext4_inode_set_file_acl(struct ext4_inode *inode, struct ext4_sblock *sb,
299 inode->file_acl_lo = to_le32((acl << 32) >> 32);
301 if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
302 inode->osd2.linux2.file_acl_high = to_le16(acl >> 32);
305 uint32_t ext4_inode_get_direct_block(struct ext4_inode *inode, uint32_t idx)
307 return to_le32(inode->blocks[idx]);
309 void ext4_inode_set_direct_block(struct ext4_inode *inode, uint32_t idx,
312 inode->blocks[idx] = to_le32(block);
315 uint32_t ext4_inode_get_indirect_block(struct ext4_inode *inode, uint32_t idx)
317 return to_le32(inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK]);
320 void ext4_inode_set_indirect_block(struct ext4_inode *inode, uint32_t idx,
323 inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK] = to_le32(block);
326 uint32_t ext4_inode_type(struct ext4_sblock *sb, struct ext4_inode *inode)
328 return (ext4_inode_get_mode(sb, inode) & EXT4_INODE_MODE_TYPE_MASK);
331 bool ext4_inode_is_type(struct ext4_sblock *sb, struct ext4_inode *inode,
334 return ext4_inode_type(sb, inode) == type;
337 bool ext4_inode_has_flag(struct ext4_inode *inode, uint32_t f)
339 return ext4_inode_get_flags(inode) & f;
342 void ext4_inode_clear_flag(struct ext4_inode *inode, uint32_t f)
344 uint32_t flags = ext4_inode_get_flags(inode);
345 flags = flags & (~f);
346 ext4_inode_set_flags(inode, flags);
349 void ext4_inode_set_flag(struct ext4_inode *inode, uint32_t f)
351 uint32_t flags = ext4_inode_get_flags(inode);
353 ext4_inode_set_flags(inode, flags);
356 bool ext4_inode_can_truncate(struct ext4_sblock *sb, struct ext4_inode *inode)
358 if ((ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND)) ||
359 (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)))
362 if ((ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)) ||
363 (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_DIRECTORY)) ||
364 (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_SOFTLINK)))
370 struct ext4_extent_header *
371 ext4_inode_get_extent_header(struct ext4_inode *inode)
373 return (struct ext4_extent_header *)inode->blocks;