libext2fs: don't use O_DIRECT for files on tmpfs

[tools/e2fsprogs.git] / lib / ext2fs / dir_iterate.c

diff --git a/lib/ext2fs/dir_iterate.c b/lib/ext2fs/dir_iterate.c
index 124862e..b2b7769 100644 (file)
--- a/lib/ext2fs/dir_iterate.c
+++ b/lib/ext2fs/dir_iterate.c
@@ -9,6 +9,7 @@
  * %End-Header%
  */
 
+#include "config.h"
 #include <stdio.h>
 #include <string.h>
 #if HAVE_UNISTD_H
@@ -82,7 +83,7 @@ static int ext2fs_validate_entry(ext2_filsys fs, char *buf,
                offset += rec_len;
                if ((rec_len < 8) ||
                    ((rec_len % 4) != 0) ||
-                   ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len))
+                   ((ext2fs_dirent_name_len(dirent)+8) > (int) rec_len))
                        return 0;
        }
        return (offset == final_offset);
@@ -122,10 +123,14 @@ errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
        ctx.func = func;
        ctx.priv_data = priv_data;
        ctx.errcode = 0;
-       retval = ext2fs_block_iterate2(fs, dir, BLOCK_FLAG_READ_ONLY, 0,
+       retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY, 0,
                                       ext2fs_process_dir_block, &ctx);
        if (!block_buf)
                ext2fs_free_mem(&ctx.buf);
+       if (retval == EXT2_ET_INLINE_DATA_CANT_ITERATE) {
+               (void) ext2fs_inline_data_dir_iterate(fs, dir, &ctx);
+               retval = 0;
+       }
        if (retval)
                return retval;
        return ctx.errcode;
@@ -150,16 +155,16 @@ static int xlate_func(ext2_ino_t dir EXT2FS_ATTR((unused)),
        return (*xl->func)(dirent, offset, blocksize, buf, xl->real_private);
 }
 
-extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
-                             ext2_ino_t dir,
-                             int flags,
-                             char *block_buf,
-                             int (*func)(struct ext2_dir_entry *dirent,
-                                         int   offset,
-                                         int   blocksize,
-                                         char  *buf,
-                                         void  *priv_data),
-                             void *priv_data)
+errcode_t ext2fs_dir_iterate(ext2_filsys fs,
+                            ext2_ino_t dir,
+                            int flags,
+                            char *block_buf,
+                            int (*func)(struct ext2_dir_entry *dirent,
+                                        int    offset,
+                                        int    blocksize,
+                                        char   *buf,
+                                        void   *priv_data),
+                            void *priv_data)
 {
        struct xlate xl;
 
@@ -176,9 +181,9 @@ extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
  * ext2fs_dir_iterate() and ext2fs_dblist_dir_iterate()
  */
 int ext2fs_process_dir_block(ext2_filsys fs,
-                            blk_t      *blocknr,
+                            blk64_t    *blocknr,
                             e2_blkcnt_t blockcnt,
-                            blk_t      ref_block EXT2FS_ATTR((unused)),
+                            blk64_t    ref_block EXT2FS_ATTR((unused)),
                             int        ref_offset EXT2FS_ATTR((unused)),
                             void       *priv_data)
 {
@@ -188,39 +193,67 @@ int ext2fs_process_dir_block(ext2_filsys fs,
        int             ret = 0;
        int             changed = 0;
        int             do_abort = 0;
-       unsigned int    rec_len, size;
+       unsigned int    rec_len, size, buflen;
        int             entry;
        struct ext2_dir_entry *dirent;
+       int             csum_size = 0;
+       int             inline_data;
+       errcode_t       retval = 0;
 
        if (blockcnt < 0)
                return 0;
 
        entry = blockcnt ? DIRENT_OTHER_FILE : DIRENT_DOT_FILE;
 
-       ctx->errcode = ext2fs_read_dir_block(fs, *blocknr, ctx->buf);
-       if (ctx->errcode)
-               return BLOCK_ABORT;
+       /* If a dir has inline data, we don't need to read block */
+       inline_data = !!(ctx->flags & DIRENT_FLAG_INCLUDE_INLINE_DATA);
+       if (!inline_data) {
+               ctx->errcode = ext2fs_read_dir_block4(fs, *blocknr, ctx->buf, 0,
+                                                     ctx->dir);
+               if (ctx->errcode)
+                       return BLOCK_ABORT;
+               /* If we handle a normal dir, we traverse the entire block */
+               buflen = fs->blocksize;
+       } else {
+               buflen = ctx->buflen;
+       }
+
+       if (ext2fs_has_feature_metadata_csum(fs->super))
+               csum_size = sizeof(struct ext2_dir_entry_tail);
 
-       while (offset < fs->blocksize) {
+       while (offset < buflen - 8) {
                dirent = (struct ext2_dir_entry *) (ctx->buf + offset);
                if (ext2fs_get_rec_len(fs, dirent, &rec_len))
                        return BLOCK_ABORT;
-               if (((offset + rec_len) > fs->blocksize) ||
+               if (((offset + rec_len) > buflen) ||
                    (rec_len < 8) ||
                    ((rec_len % 4) != 0) ||
-                   ((((unsigned) dirent->name_len & 0xFF)+8) > rec_len)) {
+                   ((ext2fs_dirent_name_len(dirent)+8) > (int) rec_len)) {
                        ctx->errcode = EXT2_ET_DIR_CORRUPTED;
                        return BLOCK_ABORT;
                }
-               if (!dirent->inode &&
-                   !(ctx->flags & DIRENT_FLAG_INCLUDE_EMPTY))
-                       goto next;
+               if (!dirent->inode) {
+                       /*
+                        * We just need to check metadata_csum when this
+                        * dir hasn't inline data.  That means that 'buflen'
+                        * should be blocksize.
+                        */
+                       if (!inline_data &&
+                           (offset == buflen - csum_size) &&
+                           (dirent->rec_len == csum_size) &&
+                           (dirent->name_len == EXT2_DIR_NAME_LEN_CSUM)) {
+                               if (!(ctx->flags & DIRENT_FLAG_INCLUDE_CSUM))
+                                       goto next;
+                               entry = DIRENT_CHECKSUM;
+                       } else if (!(ctx->flags & DIRENT_FLAG_INCLUDE_EMPTY))
+                               goto next;
+               }
 
                ret = (ctx->func)(ctx->dir,
                                  (next_real_entry > offset) ?
                                  DIRENT_DELETED_FILE : entry,
                                  dirent, offset,
-                                 fs->blocksize, ctx->buf,
+                                 buflen, ctx->buf,
                                  ctx->priv_data);
                if (entry < DIRENT_OTHER_FILE)
                        entry++;
@@ -239,7 +272,7 @@ next:
                        next_real_entry += rec_len;
 
                if (ctx->flags & DIRENT_FLAG_INCLUDE_REMOVED) {
-                       size = ((dirent->name_len & 0xFF) + 11) & ~3;
+                       size = (ext2fs_dirent_name_len(dirent) + 11) & ~3;
 
                        if (rec_len != size)  {
                                unsigned int final_offset;
@@ -258,12 +291,21 @@ next:
        }
 
        if (changed) {
-               ctx->errcode = ext2fs_write_dir_block(fs, *blocknr, ctx->buf);
-               if (ctx->errcode)
-                       return BLOCK_ABORT;
+               if (!inline_data) {
+                       ctx->errcode = ext2fs_write_dir_block4(fs, *blocknr,
+                                                              ctx->buf,
+                                                              0, ctx->dir);
+                       if (ctx->errcode)
+                               return BLOCK_ABORT;
+               } else {
+                       /*
+                        * return BLOCK_INLINE_DATA_CHANGED to notify caller
+                        * that inline data has been changed.
+                        */
+                       retval = BLOCK_INLINE_DATA_CHANGED;
+               }
        }
        if (do_abort)
-               return BLOCK_ABORT;
-       return 0;
+               return retval | BLOCK_ABORT;
+       return retval;
 }
-