lwext4/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
 112 ext4_inode_get_checksum(struct ext4_sblock *sb, struct ext4_inode *inode)
 113 {
 114         uint16_t inode_size = ext4_get16(sb, inode_size);
 115         uint32_t v = to_le16(inode->osd2.linux2.checksum_lo);
 116
 117         if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
 118                 v |= ((uint32_t)to_le16(inode->checksum_hi)) << 16;
 119
 120         return v;
 121 }
 122
 123 void
 124 ext4_inode_set_checksum(struct ext4_sblock *sb, struct ext4_inode *inode,
 125                         uint32_t checksum)
 126 {
 127         uint16_t inode_size = ext4_get16(sb, inode_size);
 128         inode->osd2.linux2.checksum_lo =
 129                 to_le16((checksum << 16) >> 16);
 130
 131         if (inode_size > EXT4_GOOD_OLD_INODE_SIZE)
 132                 inode->checksum_hi = to_le16(checksum >> 16);
 133
 134 }
 135
 136 uint32_t ext4_inode_get_access_time(struct ext4_inode *inode)
 137 {
 138         return to_le32(inode->access_time);
 139 }
 140 void ext4_inode_set_access_time(struct ext4_inode *inode, uint32_t time)
 141 {
 142         inode->access_time = to_le32(time);
 143 }
 144
 145 uint32_t ext4_inode_get_change_inode_time(struct ext4_inode *inode)
 146 {
 147         return to_le32(inode->change_inode_time);
 148 }
 149 void ext4_inode_set_change_inode_time(struct ext4_inode *inode, uint32_t time)
 150 {
 151         inode->change_inode_time = to_le32(time);
 152 }
 153
 154 uint32_t ext4_inode_get_modification_time(struct ext4_inode *inode)
 155 {
 156         return to_le32(inode->modification_time);
 157 }
 158
 159 void ext4_inode_set_modification_time(struct ext4_inode *inode, uint32_t time)
 160 {
 161         inode->modification_time = to_le32(time);
 162 }
 163
 164 uint32_t ext4_inode_get_deletion_time(struct ext4_inode *inode)
 165 {
 166         return to_le32(inode->deletion_time);
 167 }
 168
 169 void ext4_inode_set_deletion_time(struct ext4_inode *inode, uint32_t time)
 170 {
 171         inode->deletion_time = to_le32(time);
 172 }
 173
 174 uint32_t ext4_inode_get_gid(struct ext4_inode *inode)
 175 {
 176         return to_le32(inode->gid);
 177 }
 178 void ext4_inode_set_gid(struct ext4_inode *inode, uint32_t gid)
 179 {
 180         inode->gid = to_le32(gid);
 181 }
 182
 183 uint16_t ext4_inode_get_links_count(struct ext4_inode *inode)
 184 {
 185         return to_le16(inode->links_count);
 186 }
 187 void ext4_inode_set_links_count(struct ext4_inode *inode, uint16_t cnt)
 188 {
 189         inode->links_count = to_le16(cnt);
 190 }
 191
 192 uint64_t ext4_inode_get_blocks_count(struct ext4_sblock *sb,
 193                                      struct ext4_inode *inode)
 194 {
 195         uint64_t count = to_le32(inode->blocks_count_lo);
 196
 197         if (ext4_sb_has_feature_read_only(sb,
 198                                           EXT4_FRO_COM_HUGE_FILE)) {
 199
 200                 /* 48-bit field */
 201                 count |= ((uint64_t)to_le16(inode->osd2.linux2.blocks_high))
 202                          << 32;
 203
 204                 if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_HUGE_FILE)) {
 205
 206                         uint32_t block_bits = ext4_inode_block_bits_count(
 207                             ext4_sb_get_block_size(sb));
 208                         return count << (block_bits - 9);
 209                 }
 210         }
 211
 212         return count;
 213 }
 214
 215 int ext4_inode_set_blocks_count(struct ext4_sblock *sb,
 216                                 struct ext4_inode *inode, uint64_t count)
 217 {
 218         /* 32-bit maximum */
 219         uint64_t max = 0;
 220         max = ~max >> 32;
 221
 222         if (count <= max) {
 223                 inode->blocks_count_lo = to_le32(count);
 224                 inode->osd2.linux2.blocks_high = 0;
 225                 ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 226
 227                 return EOK;
 228         }
 229
 230         /* Check if there can be used huge files (many blocks) */
 231         if (!ext4_sb_has_feature_read_only(sb,
 232                                            EXT4_FRO_COM_HUGE_FILE))
 233                 return EINVAL;
 234
 235         /* 48-bit maximum */
 236         max = 0;
 237         max = ~max >> 16;
 238
 239         if (count <= max) {
 240                 inode->blocks_count_lo = to_le32(count);
 241                 inode->osd2.linux2.blocks_high = to_le16(count >> 32);
 242                 ext4_inode_clear_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 243         } else {
 244                 uint32_t block_bits =
 245                     ext4_inode_block_bits_count(ext4_sb_get_block_size(sb));
 246
 247                 ext4_inode_set_flag(inode, EXT4_INODE_FLAG_HUGE_FILE);
 248                 count = count >> (block_bits - 9);
 249                 inode->blocks_count_lo = to_le32(count);
 250                 inode->osd2.linux2.blocks_high = to_le16(count >> 32);
 251         }
 252
 253         return EOK;
 254 }
 255
 256 uint32_t ext4_inode_get_flags(struct ext4_inode *inode)
 257 {
 258         return to_le32(inode->flags);
 259 }
 260 void ext4_inode_set_flags(struct ext4_inode *inode, uint32_t flags)
 261 {
 262         inode->flags = to_le32(flags);
 263 }
 264
 265 uint32_t ext4_inode_get_generation(struct ext4_inode *inode)
 266 {
 267         return to_le32(inode->generation);
 268 }
 269 void ext4_inode_set_generation(struct ext4_inode *inode, uint32_t gen)
 270 {
 271         inode->generation = to_le32(gen);
 272 }
 273
 274 uint16_t ext4_inode_get_extra_isize(struct ext4_inode *inode)
 275 {
 276         return to_le16(inode->extra_isize);
 277 }
 278
 279 void ext4_inode_set_extra_isize(struct ext4_inode *inode, uint16_t size)
 280 {
 281         inode->extra_isize = to_le16(size);
 282 }
 283
 284 uint64_t ext4_inode_get_file_acl(struct ext4_inode *inode,
 285                                  struct ext4_sblock *sb)
 286 {
 287         /*TODO: Verify it*/
 288         uint64_t v = to_le32(inode->file_acl_lo);
 289
 290         if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
 291                 v |= ((uint32_t)to_le16(inode->osd2.linux2.file_acl_high))
 292                      << 16;
 293
 294         return v;
 295 }
 296
 297 void ext4_inode_set_file_acl(struct ext4_inode *inode, struct ext4_sblock *sb,
 298                              uint64_t acl)
 299 {
 300         /*TODO: Verify it*/
 301         inode->file_acl_lo = to_le32((acl << 32) >> 32);
 302
 303         if (ext4_get32(sb, creator_os) == EXT4_SUPERBLOCK_OS_LINUX)
 304                 inode->osd2.linux2.file_acl_high = to_le16(acl >> 32);
 305 }
 306
 307 uint32_t ext4_inode_get_direct_block(struct ext4_inode *inode, uint32_t idx)
 308 {
 309         return to_le32(inode->blocks[idx]);
 310 }
 311 void ext4_inode_set_direct_block(struct ext4_inode *inode, uint32_t idx,
 312                                  uint32_t block)
 313 {
 314         inode->blocks[idx] = to_le32(block);
 315 }
 316
 317 uint32_t ext4_inode_get_indirect_block(struct ext4_inode *inode, uint32_t idx)
 318 {
 319         return to_le32(inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK]);
 320 }
 321
 322 void ext4_inode_set_indirect_block(struct ext4_inode *inode, uint32_t idx,
 323                                    uint32_t block)
 324 {
 325         inode->blocks[idx + EXT4_INODE_INDIRECT_BLOCK] = to_le32(block);
 326 }
 327
 328 uint32_t ext4_inode_type(struct ext4_sblock *sb, struct ext4_inode *inode)
 329 {
 330         return (ext4_inode_get_mode(sb, inode) & EXT4_INODE_MODE_TYPE_MASK);
 331 }
 332
 333 bool ext4_inode_is_type(struct ext4_sblock *sb, struct ext4_inode *inode,
 334                         uint32_t type)
 335 {
 336         return ext4_inode_type(sb, inode) == type;
 337 }
 338
 339 bool ext4_inode_has_flag(struct ext4_inode *inode, uint32_t f)
 340 {
 341         return ext4_inode_get_flags(inode) & f;
 342 }
 343
 344 void ext4_inode_clear_flag(struct ext4_inode *inode, uint32_t f)
 345 {
 346         uint32_t flags = ext4_inode_get_flags(inode);
 347         flags = flags & (~f);
 348         ext4_inode_set_flags(inode, flags);
 349 }
 350
 351 void ext4_inode_set_flag(struct ext4_inode *inode, uint32_t f)
 352 {
 353         uint32_t flags = ext4_inode_get_flags(inode);
 354         flags = flags | f;
 355         ext4_inode_set_flags(inode, flags);
 356 }
 357
 358 bool ext4_inode_can_truncate(struct ext4_sblock *sb, struct ext4_inode *inode)
 359 {
 360         if ((ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND)) ||
 361             (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)))
 362                 return false;
 363
 364         if ((ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_FILE)) ||
 365             (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_DIRECTORY)) ||
 366             (ext4_inode_is_type(sb, inode, EXT4_INODE_MODE_SOFTLINK)))
 367                 return true;
 368
 369         return false;
 370 }
 371
 372 struct ext4_extent_header *
 373 ext4_inode_get_extent_header(struct ext4_inode *inode)
 374 {
 375         return (struct ext4_extent_header *)inode->blocks;
 376 }
 377
 378 /**
 379  * @}
 380  */