1 /* 2 * Copyright (c) International Business Machines Corp., 2006 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 * 6 * Author: Artem Bityutskiy (Битюцкий Артём) 7 */ 8 9 /* Here we keep miscellaneous functions which are used all over the UBI code */ 10 11 #include <ubi_uboot.h> 12 #include "ubi.h" 13 14 /** 15 * calc_data_len - calculate how much real data is stored in a buffer. 16 * @ubi: UBI device description object 17 * @buf: a buffer with the contents of the physical eraseblock 18 * @length: the buffer length 19 * 20 * This function calculates how much "real data" is stored in @buf and returnes 21 * the length. Continuous 0xFF bytes at the end of the buffer are not 22 * considered as "real data". 23 */ 24 int ubi_calc_data_len(const struct ubi_device *ubi, const void *buf, 25 int length) 26 { 27 int i; 28 29 ubi_assert(!(length & (ubi->min_io_size - 1))); 30 31 for (i = length - 1; i >= 0; i--) 32 if (((const uint8_t *)buf)[i] != 0xFF) 33 break; 34 35 /* The resulting length must be aligned to the minimum flash I/O size */ 36 length = ALIGN(i + 1, ubi->min_io_size); 37 return length; 38 } 39 40 /** 41 * ubi_check_volume - check the contents of a static volume. 42 * @ubi: UBI device description object 43 * @vol_id: ID of the volume to check 44 * 45 * This function checks if static volume @vol_id is corrupted by fully reading 46 * it and checking data CRC. This function returns %0 if the volume is not 47 * corrupted, %1 if it is corrupted and a negative error code in case of 48 * failure. Dynamic volumes are not checked and zero is returned immediately. 49 */ 50 int ubi_check_volume(struct ubi_device *ubi, int vol_id) 51 { 52 void *buf; 53 int err = 0, i; 54 struct ubi_volume *vol = ubi->volumes[vol_id]; 55 56 if (vol->vol_type != UBI_STATIC_VOLUME) 57 return 0; 58 59 buf = vmalloc(vol->usable_leb_size); 60 if (!buf) 61 return -ENOMEM; 62 63 for (i = 0; i < vol->used_ebs; i++) { 64 int size; 65 66 cond_resched(); 67 68 if (i == vol->used_ebs - 1) 69 size = vol->last_eb_bytes; 70 else 71 size = vol->usable_leb_size; 72 73 err = ubi_eba_read_leb(ubi, vol, i, buf, 0, size, 1); 74 if (err) { 75 if (mtd_is_eccerr(err)) 76 err = 1; 77 break; 78 } 79 } 80 81 vfree(buf); 82 return err; 83 } 84 85 /** 86 * ubi_update_reserved - update bad eraseblock handling accounting data. 87 * @ubi: UBI device description object 88 * 89 * This function calculates the gap between current number of PEBs reserved for 90 * bad eraseblock handling and the required level of PEBs that must be 91 * reserved, and if necessary, reserves more PEBs to fill that gap, according 92 * to availability. Should be called with ubi->volumes_lock held. 93 */ 94 void ubi_update_reserved(struct ubi_device *ubi) 95 { 96 int need = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs; 97 98 if (need <= 0 || ubi->avail_pebs == 0) 99 return; 100 101 need = min_t(int, need, ubi->avail_pebs); 102 ubi->avail_pebs -= need; 103 ubi->rsvd_pebs += need; 104 ubi->beb_rsvd_pebs += need; 105 ubi_msg(ubi, "reserved more %d PEBs for bad PEB handling", need); 106 } 107 108 /** 109 * ubi_calculate_reserved - calculate how many PEBs must be reserved for bad 110 * eraseblock handling. 111 * @ubi: UBI device description object 112 */ 113 void ubi_calculate_reserved(struct ubi_device *ubi) 114 { 115 /* 116 * Calculate the actual number of PEBs currently needed to be reserved 117 * for future bad eraseblock handling. 118 */ 119 ubi->beb_rsvd_level = ubi->bad_peb_limit - ubi->bad_peb_count; 120 if (ubi->beb_rsvd_level < 0) { 121 ubi->beb_rsvd_level = 0; 122 ubi_warn(ubi, "number of bad PEBs (%d) is above the expected limit (%d), not reserving any PEBs for bad PEB handling, will use available PEBs (if any)", 123 ubi->bad_peb_count, ubi->bad_peb_limit); 124 } 125 } 126 127 /** 128 * ubi_check_pattern - check if buffer contains only a certain byte pattern. 129 * @buf: buffer to check 130 * @patt: the pattern to check 131 * @size: buffer size in bytes 132 * 133 * This function returns %1 in there are only @patt bytes in @buf, and %0 if 134 * something else was also found. 135 */ 136 int ubi_check_pattern(const void *buf, uint8_t patt, int size) 137 { 138 int i; 139 140 for (i = 0; i < size; i++) 141 if (((const uint8_t *)buf)[i] != patt) 142 return 0; 143 return 1; 144 } 145