src/ext4_inode.c

   1 /*
   2  * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   3  *
   4  *
   5  * HelenOS:
   6  * Copyright (c) 2012 Martin Sucha
   7  * Copyright (c) 2012 Frantisek Princ
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  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.
  21  *
  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.
  32  */
  33
  34 /** @addtogroup lwext4
  35  * @{
  36  */
  37 /**
  38  * @file  ext4_inode.c
  39  * @brief Inode handle functions
  40  */
  41
  42 #include "ext4_config.h"
  43 #include "ext4_types.h"
  44 #include "ext4_inode.h"
  45 #include "ext4_super.h"
  46
  47 /**@brief  Compute number of bits for block count.
  48  * @param block_size Filesystem block_size
  49  * @return Number of bits
  50  */
  51 static uint32_t ext4_inode_block_bits_count(uint32_t block_size)
  52 {
  53         uint32_t bits = 8;
  54         uint32_t size = block_size;
  55
  56         do {
  57                 bits++;
  58                 size = size >> 1;
  59         } while (size > 256);
  60
  61         return bits;
  62 }
  63
  64 uint32_t ext4_inode_get_mode(struct ext4_sblock *sb, struct ext4_inode *inode)
  65 {
  66         uint32_t v = to_le16(inode->mode);
  67
  68         if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_HURD) {
  69                 v |= ((uint32_t)to_le16(inode->osd2.hurd2.mode_high)) << 16;
  70         }
  71
  72         return v;
  73 }
  74
  75 void ext4_inode_set_mode(struct ext4_sblock *sb, struct ext4_inode *inode,
  76                          uint32_t mode)
  77 {
  78         inode->mode = to_le16((mode << 16) >> 16);
  79
  80         if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_HURD)
  81                 inode->osd2.hurd2.mode_high = to_le16(mode >> 16);
  82 }
  83
  84 uint32_t ext4_inode_get_uid(struct ext4_inode *inode)
  85 {
  86         return to_le32(inode->uid);
  87 }
  88
  89 void ext4_inode_set_uid(struct ext4_inode *inode, uint32_t uid)
  90 {
  91         inode->uid = to_le32(uid);
  92 }
  93
  94 uint64_t ext4_inode_get_size(struct ext4_sblock *sb, struct ext4_inode *inode)
  95 {
  96         uint64_t v = to_le32(inode->size_lo);
  97
  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;
 101
 102         return v;
 103 }
 104
 105 void ext4_inode_set_size(struct ext4_inode *inode, uint64_t size)
 106 {
 107         inode->size_lo = to_le32((size << 32) >> 32);
 108         inode->size_hi = to_le32(size >> 32);
 109 }
 110
 111 uint32_t ext4_inode_get_csum(struct ext4_sblock *sb, struct ext4_inode *inode)
 112 {
 113         uint16_t inode_size = ext4_get16(sb, inode_size);
 114         uint32_t v = to_le16(inode->osd2.linux2.checksum_lo);
 115
 116         if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
 117                 v |= ((uint32_t)to_le16(inode->checksum_hi)) << 16;
 118
 119         return v;
 120 }
 121
 122 void ext4_inode_set_csum(struct ext4_sblock *sb, struct ext4_inode *inode,
 123                         uint32_t checksum)
 124 {
 125         uint16_t inode_size = ext4_get16(sb, inode_size);
 126         inode->osd2.linux2.checksum_lo =
 127                 to_le16((checksum << 16) >> 16);
 128
 129         if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
 130                 inode->checksum_hi = to_le16(checksum >> 16);
 131
 132 }
 133
 134 uint32_t ext4_inode_get_access_time(struct ext4_inode *inode)
 135 {
 136         return to_le32(inode->access_time);
 137 }
 138 void ext4_inode_set_access_time(struct ext4_inode *inode, uint32_t time)
 139 {
 140         inode->access_time = to_le32(time);
 141 }
 142
 143 uint32_t ext4_inode_get_change_inode_time(struct ext4_inode *inode)
 144 {
 145         return to_le32(inode->change_inode_time);
 146 }
 147 void ext4_inode_set_change_inode_time(struct ext4_inode *inode, uint32_t time)
 148 {
 149         inode->change_inode_time = to_le32(time);
 150 }
 151
 152 uint32_t ext4_inode_get_modif_time(struct ext4_inode *inode)
 153 {
 154         return to_le32(inode->modification_time);
 155 }
 156
 157 void ext4_inode_set_modif_time(struct ext4_inode *inode, uint32_t time)
 158 {
 159         inode->modification_time = to_le32(time);
 160 }
 161
 162 uint32_t ext4_inode_get_del_time(struct ext4_inode *inode)
 163 {
 164         return to_le32(inode->deletion_time);
 165 }
 166
 167 void ext4_inode_set_del_time(struct ext4_inode *inode, uint32_t time)
 168 {
 169         inode->deletion_time = to_le32(time);
 170 }
 171
 172 uint32_t ext4_inode_get_gid(struct ext4_inode *inode)
 173 {
 174         return to_le32(inode->gid);
 175 }
 176 void ext4_inode_set_gid(struct ext4_inode *inode, uint32_t gid)
 177 {
 178         inode->gid = to_le32(gid);
 179 }
 180
 181 uint16_t ext4_inode_get_links_cnt(struct ext4_inode *inode)
 182 {
 183         return to_le16(inode->links_count);
 184 }
 185 void ext4_inode_set_links_cnt(struct ext4_inode *inode, uint16_t cnt)
 186 {
 187         inode->links_count = to_le16(cnt);
 188 }
 189
 190 uint64_t ext4_inode_get_blocks_count(struct ext4_sblock *sb,
 191                                      struct ext4_inode *inode)
 192 {
 193         uint64_t cnt = to_le32(inode->blocks_count_lo);
 194
 195         if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_HUGE_FILE)) {
 196
 197                 /* 48-bit field */
 198                 cnt |= (uint64_t)to_le16(inode->osd2.linux2.blocks_high) << 32;
 199
 200                 if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_HUGE_FILE)) {
 201
 202                         uint32_t block_count = ext4_sb_get_block_size(sb);
 203                         uint32_t b = ext4_inode_block_bits_count(block_count);
 204                         return cnt << (b - 9);
 205                 }
 206         }
 207
 208         return cnt;
 209 }
 210
 211 int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
 212                                 struct ext4_inode *inode, uint64_t count)
 213 {
 214         /* 32-bit maximum */
 215         uint64_t max = 0;
 216         max = ~max >> 32;
 217
 218         if (count <= max) {
 219                 inode->blocks_count_lo = to_le32((uint32_t)count);
 220                 inode->osd2.linux2.blocks_high = 0;
 221                 ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 222
 223                 return EOK;
 224         }
 225
 226         /* Check if there can be used huge files (many blocks) */
 227         if (!ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_HUGE_FILE))
 228                 return EINVAL;
 229
 230         /* 48-bit maximum */
 231         max = 0;
 232         max = ~max >> 16;
 233
 234         if (count <= max) {
 235                 inode->blocks_count_lo = to_le32((uint32_t)count);
 236                 inode->osd2.linux2.blocks_high = to_le16((uint16_t)(count >> 32));
 237                 ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 238         } else {
 239                 uint32_t block_count = ext4_sb_get_block_size(sb);
 240                 uint32_t block_bits =ext4_inode_block_bits_count(block_count);
 241
 242                 ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 243                 count = count >> (block_bits - 9);
 244                 inode->blocks_count_lo = to_le32((uint32_t)count);
 245                 inode->osd2.linux2.blocks_high = to_le16((uint16_t)(count >> 32));
 246         }
 247
 248         return EOK;
 249 }
 250
 251 uint32_t ext4_inode_get_flags(struct ext4_inode *inode)
 252 {
 253         return to_le32(inode->flags);
 254 }
 255 void ext4_inode_set_flags(struct ext4_inode *inode, uint32_t flags)
 256 {
 257         inode->flags = to_le32(flags);
 258 }
 259
 260 uint32_t ext4_inode_get_generation(struct ext4_inode *inode)
 261 {
 262         return to_le32(inode->generation);
 263 }
 264 void ext4_inode_set_generation(struct ext4_inode *inode, uint32_t gen)
 265 {
 266         inode->generation = to_le32(gen);
 267 }
 268
 269 uint16_t ext4_inode_get_extra_isize(struct ext4_inode *inode)
 270 {
 271         return to_le16(inode->extra_isize);
 272 }
 273
 274 void ext4_inode_set_extra_isize(struct ext4_inode *inode, uint16_t size)
 275 {
 276         inode->extra_isize = to_le16(size);
 277 }
 278
 279 uint64_t ext4_inode_get_file_acl(struct ext4_inode *inode,
 280                                  struct ext4_sblock *sb)
 281 {
 282         uint64_t v = to_le32(inode->file_acl_lo);
 283
 284         if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
 285                 v |= (uint32_t)to_le16(inode->osd2.linux2.file_acl_high) << 16;
 286
 287         return v;
 288 }
 289
 290 void ext4_inode_set_file_acl(struct ext4_inode *inode, struct ext4_sblock *sb,
 291                              uint64_t acl)
 292 {
 293         inode->file_acl_lo = to_le32((acl << 32) >> 32);
 294
 295         if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
 296                 inode->osd2.linux2.file_acl_high = to_le16((uint16_t)(acl >> 32));
 297 }
 298
 299 uint32_t ext4_inode_get_direct_block(struct ext4_inode *inode, uint32_t idx)
 300 {
 301         return to_le32(inode->blocks[idx]);
 302 }
 303 void ext4_inode_set_direct_block(struct ext4_inode *inode, uint32_t idx,
 304                                  uint32_t block)
 305 {
 306         inode->blocks[idx] = to_le32(block);
 307 }
 308
 309 uint32_t ext4_inode_get_indirect_block(struct ext4_inode *inode, uint32_t idx)
 310 {
 311         return to_le32(inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK]);
 312 }
 313
 314 void ext4_inode_set_indirect_block(struct ext4_inode *inode, uint32_t idx,
 315                                    uint32_t block)
 316 {
 317         inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK] = to_le32(block);
 318 }
 319
 320 uint32_t ext4_inode_type(struct ext4_sblock *sb, struct ext4_inode *inode)
 321 {
 322         return (ext4_inode_get_mode(sb, inode) & EXT4_INODE_MODE_TYPE_MASK);
 323 }
 324
 325 bool ext4_inode_is_type(struct ext4_sblock *sb, struct ext4_inode *inode,
 326                         uint32_t type)
 327 {
 328         return ext4_inode_type(sb, inode) == type;
 329 }
 330
 331 bool ext4_inode_has_flag(struct ext4_inode *inode, uint32_t f)
 332 {
 333         return ext4_inode_get_flags(inode) & f;
 334 }
 335
 336 void ext4_inode_clear_flag(struct ext4_inode *inode, uint32_t f)
 337 {
 338         uint32_t flags = ext4_inode_get_flags(inode);
 339         flags = flags & (~f);
 340         ext4_inode_set_flags(inode, flags);
 341 }
 342
 343 void ext4_inode_set_flag(struct ext4_inode *inode, uint32_t f)
 344 {
 345         uint32_t flags = ext4_inode_get_flags(inode);
 346         flags = flags | f;
 347         ext4_inode_set_flags(inode, flags);
 348 }
 349
 350 bool ext4_inode_can_truncate(struct ext4_sblock *sb, struct ext4_inode *inode)
 351 {
 352         if ((ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND)) ||
 353             (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)))
 354                 return false;
 355
 356         if ((ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)) ||
 357             (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_DIRECTORY)) ||
 358             (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_SOFTLINK)))
 359                 return true;
 360
 361         return false;
 362 }
 363
 364 struct ext4_extent_header *
 365 ext4_inode_get_extent_header(struct ext4_inode *inode)
 366 {
 367         return (struct ext4_extent_header *)inode->blocks;
 368 }
 369
 370 /**
 371  * @}
 372  */