+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Copyright (C) 2020 Hyunchul Lee <hyc.lee@gmail.com>
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-#include <fcntl.h>
-
-#include "exfat_ondisk.h"
-#include "libexfat.h"
-#include "fsck.h"
-
-static ssize_t write_block(struct exfat_de_iter *iter, unsigned int block)
-{
- off_t device_offset;
- struct exfat *exfat = iter->exfat;
- struct buffer_desc *desc;
- unsigned int i;
-
- desc = &iter->buffer_desc[block & 0x01];
- device_offset = exfat_c2o(exfat, desc->p_clus) + desc->offset;
-
- for (i = 0; i < iter->read_size / iter->write_size; i++) {
- if (desc->dirty[i]) {
- if (exfat_write(exfat->blk_dev->dev_fd,
- desc->buffer + i * iter->write_size,
- iter->write_size,
- device_offset + i * iter->write_size)
- != (ssize_t)iter->write_size)
- return -EIO;
- desc->dirty[i] = 0;
- }
- }
- return 0;
-}
-
-static int read_ahead_first_blocks(struct exfat_de_iter *iter)
-{
-#ifdef POSIX_FADV_WILLNEED
- struct exfat *exfat = iter->exfat;
- clus_t clus_count;
- unsigned int size;
-
- clus_count = iter->parent->size / exfat->clus_size;
-
- if (clus_count > 1) {
- iter->ra_begin_offset = 0;
- iter->ra_next_clus = 1;
- size = exfat->clus_size;
- } else {
- iter->ra_begin_offset = 0;
- iter->ra_next_clus = 0;
- size = iter->ra_partial_size;
- }
- return posix_fadvise(exfat->blk_dev->dev_fd,
- exfat_c2o(exfat, iter->parent->first_clus), size,
- POSIX_FADV_WILLNEED);
-#else
- return -ENOTSUP;
-#endif
-}
-
-/**
- * read the next fragment in advance, and assume the fragment
- * which covers @clus is already read.
- */
-static int read_ahead_next_blocks(struct exfat_de_iter *iter,
- clus_t clus, unsigned int offset, clus_t p_clus)
-{
-#ifdef POSIX_FADV_WILLNEED
- struct exfat *exfat = iter->exfat;
- off_t device_offset;
- clus_t clus_count, ra_clus, ra_p_clus;
- unsigned int size;
- int ret = 0;
-
- clus_count = iter->parent->size / exfat->clus_size;
- if (clus + 1 < clus_count) {
- ra_clus = clus + 1;
- if (ra_clus == iter->ra_next_clus &&
- offset >= iter->ra_begin_offset) {
- ret = get_next_clus(exfat, iter->parent,
- p_clus, &ra_p_clus);
- if (ra_p_clus == EXFAT_EOF_CLUSTER)
- return -EIO;
-
- device_offset = exfat_c2o(exfat, ra_p_clus);
- size = ra_clus + 1 < clus_count ?
- exfat->clus_size : iter->ra_partial_size;
- ret = posix_fadvise(exfat->blk_dev->dev_fd,
- device_offset, size,
- POSIX_FADV_WILLNEED);
- iter->ra_next_clus = ra_clus + 1;
- iter->ra_begin_offset = 0;
- }
- } else {
- if (offset >= iter->ra_begin_offset &&
- offset + iter->ra_partial_size <=
- exfat->clus_size) {
- device_offset = exfat_c2o(exfat, p_clus) +
- offset + iter->ra_partial_size;
- ret = posix_fadvise(exfat->blk_dev->dev_fd,
- device_offset, iter->ra_partial_size,
- POSIX_FADV_WILLNEED);
- iter->ra_begin_offset =
- offset + iter->ra_partial_size;
- }
- }
-
- return ret;
-#else
- return -ENOTSUP;
-#endif
-}
-
-static int read_ahead_next_dir_blocks(struct exfat_de_iter *iter)
-{
-#ifdef POSIX_FADV_WILLNEED
- struct exfat *exfat = iter->exfat;
- struct list_head *current;
- struct exfat_inode *next_inode;
- off_t offset;
-
- if (list_empty(&exfat->dir_list))
- return -EINVAL;
-
- current = exfat->dir_list.next;
- if (iter->parent == list_entry(current, struct exfat_inode, list) &&
- current->next != &exfat->dir_list) {
- next_inode = list_entry(current->next, struct exfat_inode,
- list);
- offset = exfat_c2o(exfat, next_inode->first_clus);
- return posix_fadvise(exfat->blk_dev->dev_fd, offset,
- iter->ra_partial_size,
- POSIX_FADV_WILLNEED);
- }
-
- return 0;
-#else
- return -ENOTSUP;
-#endif
-}
-
-static ssize_t read_block(struct exfat_de_iter *iter, unsigned int block)
-{
- struct exfat *exfat = iter->exfat;
- struct buffer_desc *desc, *prev_desc;
- off_t device_offset;
- ssize_t ret;
-
- desc = &iter->buffer_desc[block & 0x01];
- if (block == 0) {
- desc->p_clus = iter->parent->first_clus;
- desc->offset = 0;
- }
-
- /* if the buffer already contains dirty dentries, write it */
- if (write_block(iter, block))
- return -EIO;
-
- if (block > 0) {
- if (block > iter->parent->size / iter->read_size)
- return EOF;
-
- prev_desc = &iter->buffer_desc[(block-1) & 0x01];
- if (prev_desc->offset + 2 * iter->read_size <=
- exfat->clus_size) {
- desc->p_clus = prev_desc->p_clus;
- desc->offset = prev_desc->offset + iter->read_size;
- } else {
- ret = get_next_clus(exfat, iter->parent,
- prev_desc->p_clus, &desc->p_clus);
- desc->offset = 0;
- if (!ret && desc->p_clus == EXFAT_EOF_CLUSTER)
- return EOF;
- else if (ret)
- return ret;
- }
- }
-
- device_offset = exfat_c2o(exfat, desc->p_clus) + desc->offset;
- ret = exfat_read(exfat->blk_dev->dev_fd, desc->buffer,
- iter->read_size, device_offset);
- if (ret <= 0)
- return ret;
-
- /*
- * if a buffer is filled with dentries, read blocks ahead of time,
- * otherwise read blocks of the next directory in advance.
- */
- if (desc->buffer[iter->read_size - 32] != EXFAT_LAST)
- read_ahead_next_blocks(iter,
- (block * iter->read_size) / exfat->clus_size,
- (block * iter->read_size) % exfat->clus_size,
- desc->p_clus);
- else
- read_ahead_next_dir_blocks(iter);
- return ret;
-}
-
-int exfat_de_iter_init(struct exfat_de_iter *iter, struct exfat *exfat,
- struct exfat_inode *dir)
-{
- iter->exfat = exfat;
- iter->parent = dir;
- iter->write_size = exfat->sect_size;
- iter->read_size = exfat->clus_size <= 4*KB ? exfat->clus_size : 4*KB;
- if (exfat->clus_size <= 32 * KB)
- iter->ra_partial_size = MAX(4 * KB, exfat->clus_size / 2);
- else
- iter->ra_partial_size = exfat->clus_size / 4;
- iter->ra_partial_size = MIN(iter->ra_partial_size, 8 * KB);
-
- if (!iter->buffer_desc)
- iter->buffer_desc = exfat->buffer_desc;
-
- if (iter->parent->size == 0)
- return EOF;
-
- read_ahead_first_blocks(iter);
- if (read_block(iter, 0) != (ssize_t)iter->read_size) {
- exfat_err("failed to read directory entries.\n");
- return -EIO;
- }
-
- iter->de_file_offset = 0;
- iter->next_read_offset = iter->read_size;
- iter->max_skip_dentries = 0;
- return 0;
-}
-
-int exfat_de_iter_get(struct exfat_de_iter *iter,
- int ith, struct exfat_dentry **dentry)
-{
- off_t next_de_file_offset;
- ssize_t ret;
- unsigned int block;
-
- next_de_file_offset = iter->de_file_offset +
- ith * sizeof(struct exfat_dentry);
- block = (unsigned int)(next_de_file_offset / iter->read_size);
-
- if (next_de_file_offset + sizeof(struct exfat_dentry) >
- iter->parent->size)
- return EOF;
- /* the dentry must be in current, or next block which will be read */
- if (block > iter->de_file_offset / iter->read_size + 1)
- return -ERANGE;
-
- /* read next cluster if needed */
- if (next_de_file_offset >= iter->next_read_offset) {
- ret = read_block(iter, block);
- if (ret != (ssize_t)iter->read_size)
- return ret;
- iter->next_read_offset += iter->read_size;
- }
-
- if (ith + 1 > iter->max_skip_dentries)
- iter->max_skip_dentries = ith + 1;
-
- *dentry = (struct exfat_dentry *)
- (iter->buffer_desc[block & 0x01].buffer +
- next_de_file_offset % iter->read_size);
- return 0;
-}
-
-int exfat_de_iter_get_dirty(struct exfat_de_iter *iter,
- int ith, struct exfat_dentry **dentry)
-{
- off_t next_file_offset;
- unsigned int block;
- int ret, sect_idx;
-
- ret = exfat_de_iter_get(iter, ith, dentry);
- if (!ret) {
- next_file_offset = iter->de_file_offset +
- ith * sizeof(struct exfat_dentry);
- block = (unsigned int)(next_file_offset / iter->read_size);
- sect_idx = (int)((next_file_offset % iter->read_size) /
- iter->write_size);
- iter->buffer_desc[block & 0x01].dirty[sect_idx] = 1;
- }
-
- return ret;
-}
-
-int exfat_de_iter_flush(struct exfat_de_iter *iter)
-{
- if (write_block(iter, 0) || write_block(iter, 1))
- return -EIO;
- return 0;
-}
-
-/*
- * @skip_dentries must be the largest @ith + 1 of exfat_de_iter_get
- * since the last call of exfat_de_iter_advance
- */
-int exfat_de_iter_advance(struct exfat_de_iter *iter, int skip_dentries)
-{
- if (skip_dentries != iter->max_skip_dentries)
- return -EINVAL;
-
- iter->max_skip_dentries = 0;
- iter->de_file_offset = iter->de_file_offset +
- skip_dentries * sizeof(struct exfat_dentry);
- return 0;
-}
-
-off_t exfat_de_iter_file_offset(struct exfat_de_iter *iter)
-{
- return iter->de_file_offset;
-}
projects / sven / exfatprogs.git / blobdiff