← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-linaro-omap/trusty

« back to all changes in this revision

Viewing changes to fs/ubifs/sb.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-57i0gl3v99b3lkfg
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/ubifs/sb.c
617
617
        c->vfs_sb->s_time_gran = le32_to_cpu(sup->time_gran);
618
618
        memcpy(&c->uuid, &sup->uuid, 16);
619
619
        c->big_lpt = !!(sup_flags & UBIFS_FLG_BIGLPT);
 
620
        c->space_fixup = !!(sup_flags & UBIFS_FLG_SPACE_FIXUP);
620
621
 
621
622
        /* Automatically increase file system size to the maximum size */
622
623
        c->old_leb_cnt = c->leb_cnt;
651
652
        kfree(sup);
652
653
        return err;
653
654
}
 
655
 
 
656
/**
 
657
 * fixup_leb - fixup/unmap an LEB containing free space.
 
658
 * @c: UBIFS file-system description object
 
659
 * @lnum: the LEB number to fix up
 
660
 * @len: number of used bytes in LEB (starting at offset 0)
 
661
 *
 
662
 * This function reads the contents of the given LEB number @lnum, then fixes
 
663
 * it up, so that empty min. I/O units in the end of LEB are actually erased on
 
664
 * flash (rather than being just all-0xff real data). If the LEB is completely
 
665
 * empty, it is simply unmapped.
 
666
 */
 
667
static int fixup_leb(struct ubifs_info *c, int lnum, int len)
 
668
{
 
669
        int err;
 
670
 
 
671
        ubifs_assert(len >= 0);
 
672
        ubifs_assert(len % c->min_io_size == 0);
 
673
        ubifs_assert(len < c->leb_size);
 
674
 
 
675
        if (len == 0) {
 
676
                dbg_mnt("unmap empty LEB %d", lnum);
 
677
                return ubi_leb_unmap(c->ubi, lnum);
 
678
        }
 
679
 
 
680
        dbg_mnt("fixup LEB %d, data len %d", lnum, len);
 
681
        err = ubi_read(c->ubi, lnum, c->sbuf, 0, len);
 
682
        if (err)
 
683
                return err;
 
684
 
 
685
        return ubi_leb_change(c->ubi, lnum, c->sbuf, len, UBI_UNKNOWN);
 
686
}
 
687
 
 
688
/**
 
689
 * fixup_free_space - find & remap all LEBs containing free space.
 
690
 * @c: UBIFS file-system description object
 
691
 *
 
692
 * This function walks through all LEBs in the filesystem and fiexes up those
 
693
 * containing free/empty space.
 
694
 */
 
695
static int fixup_free_space(struct ubifs_info *c)
 
696
{
 
697
        int lnum, err = 0;
 
698
        struct ubifs_lprops *lprops;
 
699
 
 
700
        ubifs_get_lprops(c);
 
701
 
 
702
        /* Fixup LEBs in the master area */
 
703
        for (lnum = UBIFS_MST_LNUM; lnum < UBIFS_LOG_LNUM; lnum++) {
 
704
                err = fixup_leb(c, lnum, c->mst_offs + c->mst_node_alsz);
 
705
                if (err)
 
706
                        goto out;
 
707
        }
 
708
 
 
709
        /* Unmap unused log LEBs */
 
710
        lnum = ubifs_next_log_lnum(c, c->lhead_lnum);
 
711
        while (lnum != c->ltail_lnum) {
 
712
                err = fixup_leb(c, lnum, 0);
 
713
                if (err)
 
714
                        goto out;
 
715
                lnum = ubifs_next_log_lnum(c, lnum);
 
716
        }
 
717
 
 
718
        /* Fixup the current log head */
 
719
        err = fixup_leb(c, c->lhead_lnum, c->lhead_offs);
 
720
        if (err)
 
721
                goto out;
 
722
 
 
723
        /* Fixup LEBs in the LPT area */
 
724
        for (lnum = c->lpt_first; lnum <= c->lpt_last; lnum++) {
 
725
                int free = c->ltab[lnum - c->lpt_first].free;
 
726
 
 
727
                if (free > 0) {
 
728
                        err = fixup_leb(c, lnum, c->leb_size - free);
 
729
                        if (err)
 
730
                                goto out;
 
731
                }
 
732
        }
 
733
 
 
734
        /* Unmap LEBs in the orphans area */
 
735
        for (lnum = c->orph_first; lnum <= c->orph_last; lnum++) {
 
736
                err = fixup_leb(c, lnum, 0);
 
737
                if (err)
 
738
                        goto out;
 
739
        }
 
740
 
 
741
        /* Fixup LEBs in the main area */
 
742
        for (lnum = c->main_first; lnum < c->leb_cnt; lnum++) {
 
743
                lprops = ubifs_lpt_lookup(c, lnum);
 
744
                if (IS_ERR(lprops)) {
 
745
                        err = PTR_ERR(lprops);
 
746
                        goto out;
 
747
                }
 
748
 
 
749
                if (lprops->free > 0) {
 
750
                        err = fixup_leb(c, lnum, c->leb_size - lprops->free);
 
751
                        if (err)
 
752
                                goto out;
 
753
                }
 
754
        }
 
755
 
 
756
out:
 
757
        ubifs_release_lprops(c);
 
758
        return err;
 
759
}
 
760
 
 
761
/**
 
762
 * ubifs_fixup_free_space - find & fix all LEBs with free space.
 
763
 * @c: UBIFS file-system description object
 
764
 *
 
765
 * This function fixes up LEBs containing free space on first mount, if the
 
766
 * appropriate flag was set when the FS was created. Each LEB with one or more
 
767
 * empty min. I/O unit (i.e. free-space-count > 0) is re-written, to make sure
 
768
 * the free space is actually erased. E.g., this is necessary for some NAND
 
769
 * chips, since the free space may have been programmed like real "0xff" data
 
770
 * (generating a non-0xff ECC), causing future writes to the not-really-erased
 
771
 * NAND pages to behave badly. After the space is fixed up, the superblock flag
 
772
 * is cleared, so that this is skipped for all future mounts.
 
773
 */
 
774
int ubifs_fixup_free_space(struct ubifs_info *c)
 
775
{
 
776
        int err;
 
777
        struct ubifs_sb_node *sup;
 
778
 
 
779
        ubifs_assert(c->space_fixup);
 
780
        ubifs_assert(!c->ro_mount);
 
781
 
 
782
        ubifs_msg("start fixing up free space");
 
783
 
 
784
        err = fixup_free_space(c);
 
785
        if (err)
 
786
                return err;
 
787
 
 
788
        sup = ubifs_read_sb_node(c);
 
789
        if (IS_ERR(sup))
 
790
                return PTR_ERR(sup);
 
791
 
 
792
        /* Free-space fixup is no longer required */
 
793
        c->space_fixup = 0;
 
794
        sup->flags &= cpu_to_le32(~UBIFS_FLG_SPACE_FIXUP);
 
795
 
 
796
        err = ubifs_write_sb_node(c, sup);
 
797
        kfree(sup);
 
798
        if (err)
 
799
                return err;
 
800
 
 
801
        ubifs_msg("free space fixup complete");
 
802
        return err;
 
803
}