* [linux-next:master 1478/2075] fs/btrfs/fiemap.c:822:26: warning: 'last_extent_end' may be used uninitialized
@ 2024-05-28 13:15 kernel test robot
0 siblings, 0 replies; only message in thread
From: kernel test robot @ 2024-05-28 13:15 UTC (permalink / raw)
To: Filipe Manana
Cc: oe-kbuild-all, Linux Memory Management List, David Sterba,
Johannes Thumshirn
tree: https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git master
head: 6dc544b66971c7f9909ff038b62149105272d26a
commit: 827308f8ead0e75a04ee3a5c2f47b84c67decfb2 [1478/2075] btrfs: move fiemap code into its own file
config: mips-buildonly-randconfig-r002-20221001 (https://download.01.org/0day-ci/archive/20240528/202405282148.jaF0FLhu-lkp@intel.com/config)
compiler: mips64-linux-gcc (GCC) 13.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20240528/202405282148.jaF0FLhu-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202405282148.jaF0FLhu-lkp@intel.com/
Note: it may well be a FALSE warning. FWIW you are at least aware of it now.
http://gcc.gnu.org/wiki/Better_Uninitialized_Warnings
All warnings (new ones prefixed by >>):
fs/btrfs/fiemap.c: In function 'extent_fiemap':
>> fs/btrfs/fiemap.c:822:26: warning: 'last_extent_end' may be used uninitialized [-Wmaybe-uninitialized]
822 | if (cache.cached && cache.offset + cache.len >= last_extent_end) {
| ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
fs/btrfs/fiemap.c:640:13: note: 'last_extent_end' was declared here
640 | u64 last_extent_end;
| ^~~~~~~~~~~~~~~
vim +/last_extent_end +822 fs/btrfs/fiemap.c
629
630 static int extent_fiemap(struct btrfs_inode *inode,
631 struct fiemap_extent_info *fieinfo,
632 u64 start, u64 len)
633 {
634 const u64 ino = btrfs_ino(inode);
635 struct extent_state *cached_state = NULL;
636 struct extent_state *delalloc_cached_state = NULL;
637 struct btrfs_path *path;
638 struct fiemap_cache cache = { 0 };
639 struct btrfs_backref_share_check_ctx *backref_ctx;
640 u64 last_extent_end;
641 u64 prev_extent_end;
642 u64 range_start;
643 u64 range_end;
644 const u64 sectorsize = inode->root->fs_info->sectorsize;
645 bool stopped = false;
646 int ret;
647
648 cache.entries_size = PAGE_SIZE / sizeof(struct btrfs_fiemap_entry);
649 cache.entries = kmalloc_array(cache.entries_size,
650 sizeof(struct btrfs_fiemap_entry),
651 GFP_KERNEL);
652 backref_ctx = btrfs_alloc_backref_share_check_ctx();
653 path = btrfs_alloc_path();
654 if (!cache.entries || !backref_ctx || !path) {
655 ret = -ENOMEM;
656 goto out;
657 }
658
659 restart:
660 range_start = round_down(start, sectorsize);
661 range_end = round_up(start + len, sectorsize);
662 prev_extent_end = range_start;
663
664 lock_extent(&inode->io_tree, range_start, range_end, &cached_state);
665
666 ret = fiemap_find_last_extent_offset(inode, path, &last_extent_end);
667 if (ret < 0)
668 goto out_unlock;
669 btrfs_release_path(path);
670
671 path->reada = READA_FORWARD;
672 ret = fiemap_search_slot(inode, path, range_start);
673 if (ret < 0) {
674 goto out_unlock;
675 } else if (ret > 0) {
676 /*
677 * No file extent item found, but we may have delalloc between
678 * the current offset and i_size. So check for that.
679 */
680 ret = 0;
681 goto check_eof_delalloc;
682 }
683
684 while (prev_extent_end < range_end) {
685 struct extent_buffer *leaf = path->nodes[0];
686 struct btrfs_file_extent_item *ei;
687 struct btrfs_key key;
688 u64 extent_end;
689 u64 extent_len;
690 u64 extent_offset = 0;
691 u64 extent_gen;
692 u64 disk_bytenr = 0;
693 u64 flags = 0;
694 int extent_type;
695 u8 compression;
696
697 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
698 if (key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY)
699 break;
700
701 extent_end = btrfs_file_extent_end(path);
702
703 /*
704 * The first iteration can leave us at an extent item that ends
705 * before our range's start. Move to the next item.
706 */
707 if (extent_end <= range_start)
708 goto next_item;
709
710 backref_ctx->curr_leaf_bytenr = leaf->start;
711
712 /* We have in implicit hole (NO_HOLES feature enabled). */
713 if (prev_extent_end < key.offset) {
714 const u64 hole_end = min(key.offset, range_end) - 1;
715
716 ret = fiemap_process_hole(inode, fieinfo, &cache,
717 &delalloc_cached_state,
718 backref_ctx, 0, 0, 0,
719 prev_extent_end, hole_end);
720 if (ret < 0) {
721 goto out_unlock;
722 } else if (ret > 0) {
723 /* fiemap_fill_next_extent() told us to stop. */
724 stopped = true;
725 break;
726 }
727
728 /* We've reached the end of the fiemap range, stop. */
729 if (key.offset >= range_end) {
730 stopped = true;
731 break;
732 }
733 }
734
735 extent_len = extent_end - key.offset;
736 ei = btrfs_item_ptr(leaf, path->slots[0],
737 struct btrfs_file_extent_item);
738 compression = btrfs_file_extent_compression(leaf, ei);
739 extent_type = btrfs_file_extent_type(leaf, ei);
740 extent_gen = btrfs_file_extent_generation(leaf, ei);
741
742 if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
743 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
744 if (compression == BTRFS_COMPRESS_NONE)
745 extent_offset = btrfs_file_extent_offset(leaf, ei);
746 }
747
748 if (compression != BTRFS_COMPRESS_NONE)
749 flags |= FIEMAP_EXTENT_ENCODED;
750
751 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
752 flags |= FIEMAP_EXTENT_DATA_INLINE;
753 flags |= FIEMAP_EXTENT_NOT_ALIGNED;
754 ret = emit_fiemap_extent(fieinfo, &cache, key.offset, 0,
755 extent_len, flags);
756 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
757 ret = fiemap_process_hole(inode, fieinfo, &cache,
758 &delalloc_cached_state,
759 backref_ctx,
760 disk_bytenr, extent_offset,
761 extent_gen, key.offset,
762 extent_end - 1);
763 } else if (disk_bytenr == 0) {
764 /* We have an explicit hole. */
765 ret = fiemap_process_hole(inode, fieinfo, &cache,
766 &delalloc_cached_state,
767 backref_ctx, 0, 0, 0,
768 key.offset, extent_end - 1);
769 } else {
770 /* We have a regular extent. */
771 if (fieinfo->fi_extents_max) {
772 ret = btrfs_is_data_extent_shared(inode,
773 disk_bytenr,
774 extent_gen,
775 backref_ctx);
776 if (ret < 0)
777 goto out_unlock;
778 else if (ret > 0)
779 flags |= FIEMAP_EXTENT_SHARED;
780 }
781
782 ret = emit_fiemap_extent(fieinfo, &cache, key.offset,
783 disk_bytenr + extent_offset,
784 extent_len, flags);
785 }
786
787 if (ret < 0) {
788 goto out_unlock;
789 } else if (ret > 0) {
790 /* emit_fiemap_extent() told us to stop. */
791 stopped = true;
792 break;
793 }
794
795 prev_extent_end = extent_end;
796 next_item:
797 if (fatal_signal_pending(current)) {
798 ret = -EINTR;
799 goto out_unlock;
800 }
801
802 ret = fiemap_next_leaf_item(inode, path);
803 if (ret < 0) {
804 goto out_unlock;
805 } else if (ret > 0) {
806 /* No more file extent items for this inode. */
807 break;
808 }
809 cond_resched();
810 }
811
812 check_eof_delalloc:
813 if (!stopped && prev_extent_end < range_end) {
814 ret = fiemap_process_hole(inode, fieinfo, &cache,
815 &delalloc_cached_state, backref_ctx,
816 0, 0, 0, prev_extent_end, range_end - 1);
817 if (ret < 0)
818 goto out_unlock;
819 prev_extent_end = range_end;
820 }
821
> 822 if (cache.cached && cache.offset + cache.len >= last_extent_end) {
823 const u64 i_size = i_size_read(&inode->vfs_inode);
824
825 if (prev_extent_end < i_size) {
826 u64 delalloc_start;
827 u64 delalloc_end;
828 bool delalloc;
829
830 delalloc = btrfs_find_delalloc_in_range(inode,
831 prev_extent_end,
832 i_size - 1,
833 &delalloc_cached_state,
834 &delalloc_start,
835 &delalloc_end);
836 if (!delalloc)
837 cache.flags |= FIEMAP_EXTENT_LAST;
838 } else {
839 cache.flags |= FIEMAP_EXTENT_LAST;
840 }
841 }
842
843 out_unlock:
844 unlock_extent(&inode->io_tree, range_start, range_end, &cached_state);
845
846 if (ret == BTRFS_FIEMAP_FLUSH_CACHE) {
847 btrfs_release_path(path);
848 ret = flush_fiemap_cache(fieinfo, &cache);
849 if (ret)
850 goto out;
851 len -= cache.next_search_offset - start;
852 start = cache.next_search_offset;
853 goto restart;
854 } else if (ret < 0) {
855 goto out;
856 }
857
858 /*
859 * Must free the path before emitting to the fiemap buffer because we
860 * may have a non-cloned leaf and if the fiemap buffer is memory mapped
861 * to a file, a write into it (through btrfs_page_mkwrite()) may trigger
862 * waiting for an ordered extent that in order to complete needs to
863 * modify that leaf, therefore leading to a deadlock.
864 */
865 btrfs_free_path(path);
866 path = NULL;
867
868 ret = flush_fiemap_cache(fieinfo, &cache);
869 if (ret)
870 goto out;
871
872 ret = emit_last_fiemap_cache(fieinfo, &cache);
873 out:
874 free_extent_state(delalloc_cached_state);
875 kfree(cache.entries);
876 btrfs_free_backref_share_ctx(backref_ctx);
877 btrfs_free_path(path);
878 return ret;
879 }
880
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2024-05-28 13:16 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-05-28 13:15 [linux-next:master 1478/2075] fs/btrfs/fiemap.c:822:26: warning: 'last_extent_end' may be used uninitialized kernel test robot
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.