• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  * Copyright (c) International Business Machines Corp., 2006
4  * Copyright (c) Nokia Corporation, 2006, 2007
5  *
6  * Author: Artem Bityutskiy (Битюцкий Артём)
7  */
8 
9 #ifndef __UBI_UBI_H__
10 #define __UBI_UBI_H__
11 
12 #include <linux/types.h>
13 #include <linux/list.h>
14 #include <linux/rbtree.h>
15 #include <linux/sched.h>
16 #include <linux/wait.h>
17 #include <linux/mutex.h>
18 #include <linux/rwsem.h>
19 #include <linux/spinlock.h>
20 #include <linux/fs.h>
21 #include <linux/cdev.h>
22 #include <linux/device.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
25 #include <linux/vmalloc.h>
26 #include <linux/notifier.h>
27 #include <linux/mtd/mtd.h>
28 #include <linux/mtd/ubi.h>
29 #include <linux/pgtable.h>
30 
31 #include "ubi-media.h"
32 
33 /* Maximum number of supported UBI devices */
34 #define UBI_MAX_DEVICES 32
35 
36 /* UBI name used for character devices, sysfs, etc */
37 #define UBI_NAME_STR "ubi"
38 
39 struct ubi_device;
40 
41 /* Normal UBI messages */
42 __printf(2, 3)
43 void ubi_msg(const struct ubi_device *ubi, const char *fmt, ...);
44 
45 /* UBI warning messages */
46 __printf(2, 3)
47 void ubi_warn(const struct ubi_device *ubi, const char *fmt, ...);
48 
49 /* UBI error messages */
50 __printf(2, 3)
51 void ubi_err(const struct ubi_device *ubi, const char *fmt, ...);
52 
53 /* Background thread name pattern */
54 #define UBI_BGT_NAME_PATTERN "ubi_bgt%dd"
55 
56 /*
57  * This marker in the EBA table means that the LEB is um-mapped.
58  * NOTE! It has to have the same value as %UBI_ALL.
59  */
60 #define UBI_LEB_UNMAPPED -1
61 
62 /*
63  * In case of errors, UBI tries to repeat the operation several times before
64  * returning error. The below constant defines how many times UBI re-tries.
65  */
66 #define UBI_IO_RETRIES 3
67 
68 /*
69  * Length of the protection queue. The length is effectively equivalent to the
70  * number of (global) erase cycles PEBs are protected from the wear-leveling
71  * worker.
72  */
73 #define UBI_PROT_QUEUE_LEN 10
74 
75 /* The volume ID/LEB number/erase counter is unknown */
76 #define UBI_UNKNOWN -1
77 
78 /*
79  * The UBI debugfs directory name pattern and maximum name length (3 for "ubi"
80  * + 2 for the number plus 1 for the trailing zero byte.
81  */
82 #define UBI_DFS_DIR_NAME "ubi%d"
83 #define UBI_DFS_DIR_LEN  (3 + 2 + 1)
84 
85 /*
86  * Error codes returned by the I/O sub-system.
87  *
88  * UBI_IO_FF: the read region of flash contains only 0xFFs
89  * UBI_IO_FF_BITFLIPS: the same as %UBI_IO_FF, but also also there was a data
90  *                     integrity error reported by the MTD driver
91  *                     (uncorrectable ECC error in case of NAND)
92  * UBI_IO_BAD_HDR: the EC or VID header is corrupted (bad magic or CRC)
93  * UBI_IO_BAD_HDR_EBADMSG: the same as %UBI_IO_BAD_HDR, but also there was a
94  *                         data integrity error reported by the MTD driver
95  *                         (uncorrectable ECC error in case of NAND)
96  * UBI_IO_BITFLIPS: bit-flips were detected and corrected
97  *
98  * Note, it is probably better to have bit-flip and ebadmsg as flags which can
99  * be or'ed with other error code. But this is a big change because there are
100  * may callers, so it does not worth the risk of introducing a bug
101  */
102 enum {
103 	UBI_IO_FF = 1,
104 	UBI_IO_FF_BITFLIPS,
105 	UBI_IO_BAD_HDR,
106 	UBI_IO_BAD_HDR_EBADMSG,
107 	UBI_IO_BITFLIPS,
108 };
109 
110 /*
111  * Return codes of the 'ubi_eba_copy_leb()' function.
112  *
113  * MOVE_CANCEL_RACE: canceled because the volume is being deleted, the source
114  *                   PEB was put meanwhile, or there is I/O on the source PEB
115  * MOVE_SOURCE_RD_ERR: canceled because there was a read error from the source
116  *                     PEB
117  * MOVE_TARGET_RD_ERR: canceled because there was a read error from the target
118  *                     PEB
119  * MOVE_TARGET_WR_ERR: canceled because there was a write error to the target
120  *                     PEB
121  * MOVE_TARGET_BITFLIPS: canceled because a bit-flip was detected in the
122  *                       target PEB
123  * MOVE_RETRY: retry scrubbing the PEB
124  */
125 enum {
126 	MOVE_CANCEL_RACE = 1,
127 	MOVE_SOURCE_RD_ERR,
128 	MOVE_TARGET_RD_ERR,
129 	MOVE_TARGET_WR_ERR,
130 	MOVE_TARGET_BITFLIPS,
131 	MOVE_RETRY,
132 };
133 
134 /*
135  * Return codes of the fastmap sub-system
136  *
137  * UBI_NO_FASTMAP: No fastmap super block was found
138  * UBI_BAD_FASTMAP: A fastmap was found but it's unusable
139  */
140 enum {
141 	UBI_NO_FASTMAP = 1,
142 	UBI_BAD_FASTMAP,
143 };
144 
145 /*
146  * Flags for emulate_power_cut in ubi_debug_info
147  *
148  * POWER_CUT_EC_WRITE: Emulate a power cut when writing an EC header
149  * POWER_CUT_VID_WRITE: Emulate a power cut when writing a VID header
150  */
151 enum {
152 	POWER_CUT_EC_WRITE = 0x01,
153 	POWER_CUT_VID_WRITE = 0x02,
154 };
155 
156 /**
157  * struct ubi_vid_io_buf - VID buffer used to read/write VID info to/from the
158  *			   flash.
159  * @hdr: a pointer to the VID header stored in buffer
160  * @buffer: underlying buffer
161  */
162 struct ubi_vid_io_buf {
163 	struct ubi_vid_hdr *hdr;
164 	void *buffer;
165 };
166 
167 /**
168  * struct ubi_wl_entry - wear-leveling entry.
169  * @u.rb: link in the corresponding (free/used) RB-tree
170  * @u.list: link in the protection queue
171  * @ec: erase counter
172  * @pnum: physical eraseblock number
173  *
174  * This data structure is used in the WL sub-system. Each physical eraseblock
175  * has a corresponding &struct wl_entry object which may be kept in different
176  * RB-trees. See WL sub-system for details.
177  */
178 struct ubi_wl_entry {
179 	union {
180 		struct rb_node rb;
181 		struct list_head list;
182 	} u;
183 	int ec;
184 	int pnum;
185 };
186 
187 /**
188  * struct ubi_ltree_entry - an entry in the lock tree.
189  * @rb: links RB-tree nodes
190  * @vol_id: volume ID of the locked logical eraseblock
191  * @lnum: locked logical eraseblock number
192  * @users: how many tasks are using this logical eraseblock or wait for it
193  * @mutex: read/write mutex to implement read/write access serialization to
194  *         the (@vol_id, @lnum) logical eraseblock
195  *
196  * This data structure is used in the EBA sub-system to implement per-LEB
197  * locking. When a logical eraseblock is being locked - corresponding
198  * &struct ubi_ltree_entry object is inserted to the lock tree (@ubi->ltree).
199  * See EBA sub-system for details.
200  */
201 struct ubi_ltree_entry {
202 	struct rb_node rb;
203 	int vol_id;
204 	int lnum;
205 	int users;
206 	struct rw_semaphore mutex;
207 };
208 
209 /**
210  * struct ubi_rename_entry - volume re-name description data structure.
211  * @new_name_len: new volume name length
212  * @new_name: new volume name
213  * @remove: if not zero, this volume should be removed, not re-named
214  * @desc: descriptor of the volume
215  * @list: links re-name entries into a list
216  *
217  * This data structure is utilized in the multiple volume re-name code. Namely,
218  * UBI first creates a list of &struct ubi_rename_entry objects from the
219  * &struct ubi_rnvol_req request object, and then utilizes this list to do all
220  * the job.
221  */
222 struct ubi_rename_entry {
223 	int new_name_len;
224 	char new_name[UBI_VOL_NAME_MAX + 1];
225 	int remove;
226 	struct ubi_volume_desc *desc;
227 	struct list_head list;
228 };
229 
230 struct ubi_volume_desc;
231 
232 /**
233  * struct ubi_fastmap_layout - in-memory fastmap data structure.
234  * @e: PEBs used by the current fastmap
235  * @to_be_tortured: if non-zero tortured this PEB
236  * @used_blocks: number of used PEBs
237  * @max_pool_size: maximal size of the user pool
238  * @max_wl_pool_size: maximal size of the pool used by the WL sub-system
239  */
240 struct ubi_fastmap_layout {
241 	struct ubi_wl_entry *e[UBI_FM_MAX_BLOCKS];
242 	int to_be_tortured[UBI_FM_MAX_BLOCKS];
243 	int used_blocks;
244 	int max_pool_size;
245 	int max_wl_pool_size;
246 };
247 
248 /**
249  * struct ubi_fm_pool - in-memory fastmap pool
250  * @pebs: PEBs in this pool
251  * @used: number of used PEBs
252  * @size: total number of PEBs in this pool
253  * @max_size: maximal size of the pool
254  *
255  * A pool gets filled with up to max_size.
256  * If all PEBs within the pool are used a new fastmap will be written
257  * to the flash and the pool gets refilled with empty PEBs.
258  *
259  */
260 struct ubi_fm_pool {
261 	int pebs[UBI_FM_MAX_POOL_SIZE];
262 	int used;
263 	int size;
264 	int max_size;
265 };
266 
267 /**
268  * struct ubi_eba_leb_desc - EBA logical eraseblock descriptor
269  * @lnum: the logical eraseblock number
270  * @pnum: the physical eraseblock where the LEB can be found
271  *
272  * This structure is here to hide EBA's internal from other part of the
273  * UBI implementation.
274  *
275  * One can query the position of a LEB by calling ubi_eba_get_ldesc().
276  */
277 struct ubi_eba_leb_desc {
278 	int lnum;
279 	int pnum;
280 };
281 
282 /**
283  * struct ubi_volume - UBI volume description data structure.
284  * @dev: device object to make use of the the Linux device model
285  * @cdev: character device object to create character device
286  * @ubi: reference to the UBI device description object
287  * @vol_id: volume ID
288  * @ref_count: volume reference count
289  * @readers: number of users holding this volume in read-only mode
290  * @writers: number of users holding this volume in read-write mode
291  * @exclusive: whether somebody holds this volume in exclusive mode
292  * @metaonly: whether somebody is altering only meta data of this volume
293  *
294  * @reserved_pebs: how many physical eraseblocks are reserved for this volume
295  * @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
296  * @usable_leb_size: logical eraseblock size without padding
297  * @used_ebs: how many logical eraseblocks in this volume contain data
298  * @last_eb_bytes: how many bytes are stored in the last logical eraseblock
299  * @used_bytes: how many bytes of data this volume contains
300  * @alignment: volume alignment
301  * @data_pad: how many bytes are not used at the end of physical eraseblocks to
302  *            satisfy the requested alignment
303  * @name_len: volume name length
304  * @name: volume name
305  *
306  * @upd_ebs: how many eraseblocks are expected to be updated
307  * @ch_lnum: LEB number which is being changing by the atomic LEB change
308  *           operation
309  * @upd_bytes: how many bytes are expected to be received for volume update or
310  *             atomic LEB change
311  * @upd_received: how many bytes were already received for volume update or
312  *                atomic LEB change
313  * @upd_buf: update buffer which is used to collect update data or data for
314  *           atomic LEB change
315  *
316  * @eba_tbl: EBA table of this volume (LEB->PEB mapping)
317  * @skip_check: %1 if CRC check of this static volume should be skipped.
318  *		Directly reflects the presence of the
319  *		%UBI_VTBL_SKIP_CRC_CHECK_FLG flag in the vtbl entry
320  * @checked: %1 if this static volume was checked
321  * @corrupted: %1 if the volume is corrupted (static volumes only)
322  * @upd_marker: %1 if the update marker is set for this volume
323  * @updating: %1 if the volume is being updated
324  * @changing_leb: %1 if the atomic LEB change ioctl command is in progress
325  * @direct_writes: %1 if direct writes are enabled for this volume
326  *
327  * @checkmap: bitmap to remember which PEB->LEB mappings got checked,
328  *            protected by UBI LEB lock tree.
329  *
330  * The @corrupted field indicates that the volume's contents is corrupted.
331  * Since UBI protects only static volumes, this field is not relevant to
332  * dynamic volumes - it is user's responsibility to assure their data
333  * integrity.
334  *
335  * The @upd_marker flag indicates that this volume is either being updated at
336  * the moment or is damaged because of an unclean reboot.
337  */
338 struct ubi_volume {
339 	struct device dev;
340 	struct cdev cdev;
341 	struct ubi_device *ubi;
342 	int vol_id;
343 	int ref_count;
344 	int readers;
345 	int writers;
346 	int exclusive;
347 	int metaonly;
348 
349 	int reserved_pebs;
350 	int vol_type;
351 	int usable_leb_size;
352 	int used_ebs;
353 	int last_eb_bytes;
354 	long long used_bytes;
355 	int alignment;
356 	int data_pad;
357 	int name_len;
358 	char name[UBI_VOL_NAME_MAX + 1];
359 
360 	int upd_ebs;
361 	int ch_lnum;
362 	long long upd_bytes;
363 	long long upd_received;
364 	void *upd_buf;
365 
366 	struct ubi_eba_table *eba_tbl;
367 	unsigned int skip_check:1;
368 	unsigned int checked:1;
369 	unsigned int corrupted:1;
370 	unsigned int upd_marker:1;
371 	unsigned int updating:1;
372 	unsigned int changing_leb:1;
373 	unsigned int direct_writes:1;
374 
375 #ifdef CONFIG_MTD_UBI_FASTMAP
376 	unsigned long *checkmap;
377 #endif
378 };
379 
380 /**
381  * struct ubi_volume_desc - UBI volume descriptor returned when it is opened.
382  * @vol: reference to the corresponding volume description object
383  * @mode: open mode (%UBI_READONLY, %UBI_READWRITE, %UBI_EXCLUSIVE
384  * or %UBI_METAONLY)
385  */
386 struct ubi_volume_desc {
387 	struct ubi_volume *vol;
388 	int mode;
389 };
390 
391 struct ubi_wl_entry;
392 
393 /**
394  * struct ubi_debug_info - debugging information for an UBI device.
395  *
396  * @chk_gen: if UBI general extra checks are enabled
397  * @chk_io: if UBI I/O extra checks are enabled
398  * @chk_fastmap: if UBI fastmap extra checks are enabled
399  * @disable_bgt: disable the background task for testing purposes
400  * @emulate_bitflips: emulate bit-flips for testing purposes
401  * @emulate_io_failures: emulate write/erase failures for testing purposes
402  * @emulate_power_cut: emulate power cut for testing purposes
403  * @power_cut_counter: count down for writes left until emulated power cut
404  * @power_cut_min: minimum number of writes before emulating a power cut
405  * @power_cut_max: maximum number of writes until emulating a power cut
406  * @dfs_dir_name: name of debugfs directory containing files of this UBI device
407  * @dfs_dir: direntry object of the UBI device debugfs directory
408  * @dfs_chk_gen: debugfs knob to enable UBI general extra checks
409  * @dfs_chk_io: debugfs knob to enable UBI I/O extra checks
410  * @dfs_chk_fastmap: debugfs knob to enable UBI fastmap extra checks
411  * @dfs_disable_bgt: debugfs knob to disable the background task
412  * @dfs_emulate_bitflips: debugfs knob to emulate bit-flips
413  * @dfs_emulate_io_failures: debugfs knob to emulate write/erase failures
414  * @dfs_emulate_power_cut: debugfs knob to emulate power cuts
415  * @dfs_power_cut_min: debugfs knob for minimum writes before power cut
416  * @dfs_power_cut_max: debugfs knob for maximum writes until power cut
417  */
418 struct ubi_debug_info {
419 	unsigned int chk_gen:1;
420 	unsigned int chk_io:1;
421 	unsigned int chk_fastmap:1;
422 	unsigned int disable_bgt:1;
423 	unsigned int emulate_bitflips:1;
424 	unsigned int emulate_io_failures:1;
425 	unsigned int emulate_power_cut:2;
426 	unsigned int power_cut_counter;
427 	unsigned int power_cut_min;
428 	unsigned int power_cut_max;
429 	char dfs_dir_name[UBI_DFS_DIR_LEN + 1];
430 	struct dentry *dfs_dir;
431 	struct dentry *dfs_chk_gen;
432 	struct dentry *dfs_chk_io;
433 	struct dentry *dfs_chk_fastmap;
434 	struct dentry *dfs_disable_bgt;
435 	struct dentry *dfs_emulate_bitflips;
436 	struct dentry *dfs_emulate_io_failures;
437 	struct dentry *dfs_emulate_power_cut;
438 	struct dentry *dfs_power_cut_min;
439 	struct dentry *dfs_power_cut_max;
440 };
441 
442 /**
443  * struct ubi_device - UBI device description structure
444  * @dev: UBI device object to use the the Linux device model
445  * @cdev: character device object to create character device
446  * @ubi_num: UBI device number
447  * @ubi_name: UBI device name
448  * @vol_count: number of volumes in this UBI device
449  * @volumes: volumes of this UBI device
450  * @volumes_lock: protects @volumes, @rsvd_pebs, @avail_pebs, beb_rsvd_pebs,
451  *                @beb_rsvd_level, @bad_peb_count, @good_peb_count, @vol_count,
452  *                @vol->readers, @vol->writers, @vol->exclusive,
453  *                @vol->metaonly, @vol->ref_count, @vol->mapping and
454  *                @vol->eba_tbl.
455  * @ref_count: count of references on the UBI device
456  * @image_seq: image sequence number recorded on EC headers
457  *
458  * @rsvd_pebs: count of reserved physical eraseblocks
459  * @avail_pebs: count of available physical eraseblocks
460  * @beb_rsvd_pebs: how many physical eraseblocks are reserved for bad PEB
461  *                 handling
462  * @beb_rsvd_level: normal level of PEBs reserved for bad PEB handling
463  *
464  * @autoresize_vol_id: ID of the volume which has to be auto-resized at the end
465  *                     of UBI initialization
466  * @vtbl_slots: how many slots are available in the volume table
467  * @vtbl_size: size of the volume table in bytes
468  * @vtbl: in-RAM volume table copy
469  * @device_mutex: protects on-flash volume table and serializes volume
470  *                creation, deletion, update, re-size, re-name and set
471  *                property
472  *
473  * @max_ec: current highest erase counter value
474  * @mean_ec: current mean erase counter value
475  *
476  * @global_sqnum: global sequence number
477  * @ltree_lock: protects the lock tree and @global_sqnum
478  * @ltree: the lock tree
479  * @alc_mutex: serializes "atomic LEB change" operations
480  *
481  * @fm_disabled: non-zero if fastmap is disabled (default)
482  * @fm: in-memory data structure of the currently used fastmap
483  * @fm_pool: in-memory data structure of the fastmap pool
484  * @fm_wl_pool: in-memory data structure of the fastmap pool used by the WL
485  *		sub-system
486  * @fm_protect: serializes ubi_update_fastmap(), protects @fm_buf and makes sure
487  * that critical sections cannot be interrupted by ubi_update_fastmap()
488  * @fm_buf: vmalloc()'d buffer which holds the raw fastmap
489  * @fm_size: fastmap size in bytes
490  * @fm_eba_sem: allows ubi_update_fastmap() to block EBA table changes
491  * @fm_work: fastmap work queue
492  * @fm_work_scheduled: non-zero if fastmap work was scheduled
493  * @fast_attach: non-zero if UBI was attached by fastmap
494  * @fm_anchor: The next anchor PEB to use for fastmap
495  * @fm_do_produce_anchor: If true produce an anchor PEB in wl
496  *
497  * @used: RB-tree of used physical eraseblocks
498  * @erroneous: RB-tree of erroneous used physical eraseblocks
499  * @free: RB-tree of free physical eraseblocks
500  * @free_count: Contains the number of elements in @free
501  * @scrub: RB-tree of physical eraseblocks which need scrubbing
502  * @pq: protection queue (contain physical eraseblocks which are temporarily
503  *      protected from the wear-leveling worker)
504  * @pq_head: protection queue head
505  * @wl_lock: protects the @used, @free, @pq, @pq_head, @lookuptbl, @move_from,
506  *	     @move_to, @move_to_put @erase_pending, @wl_scheduled, @works,
507  *	     @erroneous, @erroneous_peb_count, @fm_work_scheduled, @fm_pool,
508  *	     and @fm_wl_pool fields
509  * @move_mutex: serializes eraseblock moves
510  * @work_sem: used to wait for all the scheduled works to finish and prevent
511  * new works from being submitted
512  * @wl_scheduled: non-zero if the wear-leveling was scheduled
513  * @lookuptbl: a table to quickly find a &struct ubi_wl_entry object for any
514  *             physical eraseblock
515  * @move_from: physical eraseblock from where the data is being moved
516  * @move_to: physical eraseblock where the data is being moved to
517  * @move_to_put: if the "to" PEB was put
518  * @works: list of pending works
519  * @works_count: count of pending works
520  * @bgt_thread: background thread description object
521  * @thread_enabled: if the background thread is enabled
522  * @bgt_name: background thread name
523  *
524  * @flash_size: underlying MTD device size (in bytes)
525  * @peb_count: count of physical eraseblocks on the MTD device
526  * @peb_size: physical eraseblock size
527  * @bad_peb_limit: top limit of expected bad physical eraseblocks
528  * @bad_peb_count: count of bad physical eraseblocks
529  * @good_peb_count: count of good physical eraseblocks
530  * @corr_peb_count: count of corrupted physical eraseblocks (preserved and not
531  *                  used by UBI)
532  * @erroneous_peb_count: count of erroneous physical eraseblocks in @erroneous
533  * @max_erroneous: maximum allowed amount of erroneous physical eraseblocks
534  * @min_io_size: minimal input/output unit size of the underlying MTD device
535  * @hdrs_min_io_size: minimal I/O unit size used for VID and EC headers
536  * @ro_mode: if the UBI device is in read-only mode
537  * @leb_size: logical eraseblock size
538  * @leb_start: starting offset of logical eraseblocks within physical
539  *             eraseblocks
540  * @ec_hdr_alsize: size of the EC header aligned to @hdrs_min_io_size
541  * @vid_hdr_alsize: size of the VID header aligned to @hdrs_min_io_size
542  * @vid_hdr_offset: starting offset of the volume identifier header (might be
543  *                  unaligned)
544  * @vid_hdr_aloffset: starting offset of the VID header aligned to
545  *                    @hdrs_min_io_size
546  * @vid_hdr_shift: contains @vid_hdr_offset - @vid_hdr_aloffset
547  * @bad_allowed: whether the MTD device admits bad physical eraseblocks or not
548  * @nor_flash: non-zero if working on top of NOR flash
549  * @max_write_size: maximum amount of bytes the underlying flash can write at a
550  *                  time (MTD write buffer size)
551  * @mtd: MTD device descriptor
552  *
553  * @peb_buf: a buffer of PEB size used for different purposes
554  * @buf_mutex: protects @peb_buf
555  * @ckvol_mutex: serializes static volume checking when opening
556  *
557  * @dbg: debugging information for this UBI device
558  */
559 struct ubi_device {
560 	struct cdev cdev;
561 	struct device dev;
562 	int ubi_num;
563 	char ubi_name[sizeof(UBI_NAME_STR)+5];
564 	int vol_count;
565 	struct ubi_volume *volumes[UBI_MAX_VOLUMES+UBI_INT_VOL_COUNT];
566 	spinlock_t volumes_lock;
567 	int ref_count;
568 	int image_seq;
569 
570 	int rsvd_pebs;
571 	int avail_pebs;
572 	int beb_rsvd_pebs;
573 	int beb_rsvd_level;
574 	int bad_peb_limit;
575 
576 	int autoresize_vol_id;
577 	int vtbl_slots;
578 	int vtbl_size;
579 	struct ubi_vtbl_record *vtbl;
580 	struct mutex device_mutex;
581 
582 	int max_ec;
583 	/* Note, mean_ec is not updated run-time - should be fixed */
584 	int mean_ec;
585 
586 	/* EBA sub-system's stuff */
587 	unsigned long long global_sqnum;
588 	spinlock_t ltree_lock;
589 	struct rb_root ltree;
590 	struct mutex alc_mutex;
591 
592 	/* Fastmap stuff */
593 	int fm_disabled;
594 	struct ubi_fastmap_layout *fm;
595 	struct ubi_fm_pool fm_pool;
596 	struct ubi_fm_pool fm_wl_pool;
597 	struct rw_semaphore fm_eba_sem;
598 	struct rw_semaphore fm_protect;
599 	void *fm_buf;
600 	size_t fm_size;
601 	struct work_struct fm_work;
602 	int fm_work_scheduled;
603 	int fast_attach;
604 	struct ubi_wl_entry *fm_anchor;
605 	int fm_do_produce_anchor;
606 
607 	/* Wear-leveling sub-system's stuff */
608 	struct rb_root used;
609 	struct rb_root erroneous;
610 	struct rb_root free;
611 	int free_count;
612 	struct rb_root scrub;
613 	struct list_head pq[UBI_PROT_QUEUE_LEN];
614 	int pq_head;
615 	spinlock_t wl_lock;
616 	struct mutex move_mutex;
617 	struct rw_semaphore work_sem;
618 	int wl_scheduled;
619 	struct ubi_wl_entry **lookuptbl;
620 	struct ubi_wl_entry *move_from;
621 	struct ubi_wl_entry *move_to;
622 	int move_to_put;
623 	struct list_head works;
624 	int works_count;
625 	struct task_struct *bgt_thread;
626 	int thread_enabled;
627 	char bgt_name[sizeof(UBI_BGT_NAME_PATTERN)+2];
628 
629 	/* I/O sub-system's stuff */
630 	long long flash_size;
631 	int peb_count;
632 	int peb_size;
633 	int bad_peb_count;
634 	int good_peb_count;
635 	int corr_peb_count;
636 	int erroneous_peb_count;
637 	int max_erroneous;
638 	int min_io_size;
639 	int hdrs_min_io_size;
640 	int ro_mode;
641 	int leb_size;
642 	int leb_start;
643 	int ec_hdr_alsize;
644 	int vid_hdr_alsize;
645 	int vid_hdr_offset;
646 	int vid_hdr_aloffset;
647 	int vid_hdr_shift;
648 	unsigned int bad_allowed:1;
649 	unsigned int nor_flash:1;
650 	int max_write_size;
651 	struct mtd_info *mtd;
652 
653 	void *peb_buf;
654 	struct mutex buf_mutex;
655 	struct mutex ckvol_mutex;
656 
657 	struct ubi_debug_info dbg;
658 };
659 
660 /**
661  * struct ubi_ainf_peb - attach information about a physical eraseblock.
662  * @ec: erase counter (%UBI_UNKNOWN if it is unknown)
663  * @pnum: physical eraseblock number
664  * @vol_id: ID of the volume this LEB belongs to
665  * @lnum: logical eraseblock number
666  * @scrub: if this physical eraseblock needs scrubbing
667  * @copy_flag: this LEB is a copy (@copy_flag is set in VID header of this LEB)
668  * @sqnum: sequence number
669  * @u: unions RB-tree or @list links
670  * @u.rb: link in the per-volume RB-tree of &struct ubi_ainf_peb objects
671  * @u.list: link in one of the eraseblock lists
672  *
673  * One object of this type is allocated for each physical eraseblock when
674  * attaching an MTD device. Note, if this PEB does not belong to any LEB /
675  * volume, the @vol_id and @lnum fields are initialized to %UBI_UNKNOWN.
676  */
677 struct ubi_ainf_peb {
678 	int ec;
679 	int pnum;
680 	int vol_id;
681 	int lnum;
682 	unsigned int scrub:1;
683 	unsigned int copy_flag:1;
684 	unsigned long long sqnum;
685 	union {
686 		struct rb_node rb;
687 		struct list_head list;
688 	} u;
689 };
690 
691 /**
692  * struct ubi_ainf_volume - attaching information about a volume.
693  * @vol_id: volume ID
694  * @highest_lnum: highest logical eraseblock number in this volume
695  * @leb_count: number of logical eraseblocks in this volume
696  * @vol_type: volume type
697  * @used_ebs: number of used logical eraseblocks in this volume (only for
698  *            static volumes)
699  * @last_data_size: amount of data in the last logical eraseblock of this
700  *                  volume (always equivalent to the usable logical eraseblock
701  *                  size in case of dynamic volumes)
702  * @data_pad: how many bytes at the end of logical eraseblocks of this volume
703  *            are not used (due to volume alignment)
704  * @compat: compatibility flags of this volume
705  * @rb: link in the volume RB-tree
706  * @root: root of the RB-tree containing all the eraseblock belonging to this
707  *        volume (&struct ubi_ainf_peb objects)
708  *
709  * One object of this type is allocated for each volume when attaching an MTD
710  * device.
711  */
712 struct ubi_ainf_volume {
713 	int vol_id;
714 	int highest_lnum;
715 	int leb_count;
716 	int vol_type;
717 	int used_ebs;
718 	int last_data_size;
719 	int data_pad;
720 	int compat;
721 	struct rb_node rb;
722 	struct rb_root root;
723 };
724 
725 /**
726  * struct ubi_attach_info - MTD device attaching information.
727  * @volumes: root of the volume RB-tree
728  * @corr: list of corrupted physical eraseblocks
729  * @free: list of free physical eraseblocks
730  * @erase: list of physical eraseblocks which have to be erased
731  * @alien: list of physical eraseblocks which should not be used by UBI (e.g.,
732  *         those belonging to "preserve"-compatible internal volumes)
733  * @fastmap: list of physical eraseblocks which relate to fastmap (e.g.,
734  *           eraseblocks of the current and not yet erased old fastmap blocks)
735  * @corr_peb_count: count of PEBs in the @corr list
736  * @empty_peb_count: count of PEBs which are presumably empty (contain only
737  *                   0xFF bytes)
738  * @alien_peb_count: count of PEBs in the @alien list
739  * @bad_peb_count: count of bad physical eraseblocks
740  * @maybe_bad_peb_count: count of bad physical eraseblocks which are not marked
741  *                       as bad yet, but which look like bad
742  * @vols_found: number of volumes found
743  * @highest_vol_id: highest volume ID
744  * @is_empty: flag indicating whether the MTD device is empty or not
745  * @force_full_scan: flag indicating whether we need to do a full scan and drop
746 		     all existing Fastmap data structures
747  * @min_ec: lowest erase counter value
748  * @max_ec: highest erase counter value
749  * @max_sqnum: highest sequence number value
750  * @mean_ec: mean erase counter value
751  * @ec_sum: a temporary variable used when calculating @mean_ec
752  * @ec_count: a temporary variable used when calculating @mean_ec
753  * @aeb_slab_cache: slab cache for &struct ubi_ainf_peb objects
754  * @ech: temporary EC header. Only available during scan
755  * @vidh: temporary VID buffer. Only available during scan
756  *
757  * This data structure contains the result of attaching an MTD device and may
758  * be used by other UBI sub-systems to build final UBI data structures, further
759  * error-recovery and so on.
760  */
761 struct ubi_attach_info {
762 	struct rb_root volumes;
763 	struct list_head corr;
764 	struct list_head free;
765 	struct list_head erase;
766 	struct list_head alien;
767 	struct list_head fastmap;
768 	int corr_peb_count;
769 	int empty_peb_count;
770 	int alien_peb_count;
771 	int bad_peb_count;
772 	int maybe_bad_peb_count;
773 	int vols_found;
774 	int highest_vol_id;
775 	int is_empty;
776 	int force_full_scan;
777 	int min_ec;
778 	int max_ec;
779 	unsigned long long max_sqnum;
780 	int mean_ec;
781 	uint64_t ec_sum;
782 	int ec_count;
783 	struct kmem_cache *aeb_slab_cache;
784 	struct ubi_ec_hdr *ech;
785 	struct ubi_vid_io_buf *vidb;
786 };
787 
788 /**
789  * struct ubi_work - UBI work description data structure.
790  * @list: a link in the list of pending works
791  * @func: worker function
792  * @e: physical eraseblock to erase
793  * @vol_id: the volume ID on which this erasure is being performed
794  * @lnum: the logical eraseblock number
795  * @torture: if the physical eraseblock has to be tortured
796  *
797  * The @func pointer points to the worker function. If the @shutdown argument is
798  * not zero, the worker has to free the resources and exit immediately as the
799  * WL sub-system is shutting down.
800  * The worker has to return zero in case of success and a negative error code in
801  * case of failure.
802  */
803 struct ubi_work {
804 	struct list_head list;
805 	int (*func)(struct ubi_device *ubi, struct ubi_work *wrk, int shutdown);
806 	/* The below fields are only relevant to erasure works */
807 	struct ubi_wl_entry *e;
808 	int vol_id;
809 	int lnum;
810 	int torture;
811 };
812 
813 #include "debug.h"
814 
815 extern struct kmem_cache *ubi_wl_entry_slab;
816 extern const struct file_operations ubi_ctrl_cdev_operations;
817 extern const struct file_operations ubi_cdev_operations;
818 extern const struct file_operations ubi_vol_cdev_operations;
819 extern struct class ubi_class;
820 extern struct mutex ubi_devices_mutex;
821 extern struct blocking_notifier_head ubi_notifiers;
822 
823 /* attach.c */
824 struct ubi_ainf_peb *ubi_alloc_aeb(struct ubi_attach_info *ai, int pnum,
825 				   int ec);
826 void ubi_free_aeb(struct ubi_attach_info *ai, struct ubi_ainf_peb *aeb);
827 int ubi_add_to_av(struct ubi_device *ubi, struct ubi_attach_info *ai, int pnum,
828 		  int ec, const struct ubi_vid_hdr *vid_hdr, int bitflips);
829 struct ubi_ainf_volume *ubi_add_av(struct ubi_attach_info *ai, int vol_id);
830 struct ubi_ainf_volume *ubi_find_av(const struct ubi_attach_info *ai,
831 				    int vol_id);
832 void ubi_remove_av(struct ubi_attach_info *ai, struct ubi_ainf_volume *av);
833 struct ubi_ainf_peb *ubi_early_get_peb(struct ubi_device *ubi,
834 				       struct ubi_attach_info *ai);
835 int ubi_attach(struct ubi_device *ubi, int force_scan);
836 void ubi_destroy_ai(struct ubi_attach_info *ai);
837 
838 /* vtbl.c */
839 int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
840 			   struct ubi_vtbl_record *vtbl_rec);
841 int ubi_vtbl_rename_volumes(struct ubi_device *ubi,
842 			    struct list_head *rename_list);
843 int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_attach_info *ai);
844 
845 /* vmt.c */
846 int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req);
847 int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl);
848 int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs);
849 int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list);
850 int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol);
851 void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol);
852 
853 /* upd.c */
854 int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
855 		     long long bytes);
856 int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
857 			 const void __user *buf, int count);
858 int ubi_start_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
859 			 const struct ubi_leb_change_req *req);
860 int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol,
861 			     const void __user *buf, int count);
862 
863 /* misc.c */
864 int ubi_calc_data_len(const struct ubi_device *ubi, const void *buf,
865 		      int length);
866 int ubi_check_volume(struct ubi_device *ubi, int vol_id);
867 void ubi_update_reserved(struct ubi_device *ubi);
868 void ubi_calculate_reserved(struct ubi_device *ubi);
869 int ubi_check_pattern(const void *buf, uint8_t patt, int size);
870 
ubi_leb_valid(struct ubi_volume * vol,int lnum)871 static inline bool ubi_leb_valid(struct ubi_volume *vol, int lnum)
872 {
873 	return lnum >= 0 && lnum < vol->reserved_pebs;
874 }
875 
876 /* eba.c */
877 struct ubi_eba_table *ubi_eba_create_table(struct ubi_volume *vol,
878 					   int nentries);
879 void ubi_eba_destroy_table(struct ubi_eba_table *tbl);
880 void ubi_eba_copy_table(struct ubi_volume *vol, struct ubi_eba_table *dst,
881 			int nentries);
882 void ubi_eba_replace_table(struct ubi_volume *vol, struct ubi_eba_table *tbl);
883 void ubi_eba_get_ldesc(struct ubi_volume *vol, int lnum,
884 		       struct ubi_eba_leb_desc *ldesc);
885 bool ubi_eba_is_mapped(struct ubi_volume *vol, int lnum);
886 int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
887 		      int lnum);
888 int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
889 		     void *buf, int offset, int len, int check);
890 int ubi_eba_read_leb_sg(struct ubi_device *ubi, struct ubi_volume *vol,
891 			struct ubi_sgl *sgl, int lnum, int offset, int len,
892 			int check);
893 int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
894 		      const void *buf, int offset, int len);
895 int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
896 			 int lnum, const void *buf, int len, int used_ebs);
897 int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
898 			      int lnum, const void *buf, int len);
899 int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
900 		     struct ubi_vid_io_buf *vidb);
901 int ubi_eba_init(struct ubi_device *ubi, struct ubi_attach_info *ai);
902 unsigned long long ubi_next_sqnum(struct ubi_device *ubi);
903 int self_check_eba(struct ubi_device *ubi, struct ubi_attach_info *ai_fastmap,
904 		   struct ubi_attach_info *ai_scan);
905 
906 /* wl.c */
907 int ubi_wl_get_peb(struct ubi_device *ubi);
908 int ubi_wl_put_peb(struct ubi_device *ubi, int vol_id, int lnum,
909 		   int pnum, int torture);
910 int ubi_wl_flush(struct ubi_device *ubi, int vol_id, int lnum);
911 int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum);
912 int ubi_wl_init(struct ubi_device *ubi, struct ubi_attach_info *ai);
913 void ubi_wl_close(struct ubi_device *ubi);
914 int ubi_thread(void *u);
915 struct ubi_wl_entry *ubi_wl_get_fm_peb(struct ubi_device *ubi, int anchor);
916 int ubi_wl_put_fm_peb(struct ubi_device *ubi, struct ubi_wl_entry *used_e,
917 		      int lnum, int torture);
918 int ubi_is_erase_work(struct ubi_work *wrk);
919 void ubi_refill_pools(struct ubi_device *ubi);
920 int ubi_ensure_anchor_pebs(struct ubi_device *ubi);
921 int ubi_bitflip_check(struct ubi_device *ubi, int pnum, int force_scrub);
922 
923 /* io.c */
924 int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
925 		int len);
926 int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
927 		 int len);
928 int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture);
929 int ubi_io_is_bad(const struct ubi_device *ubi, int pnum);
930 int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum);
931 int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
932 		       struct ubi_ec_hdr *ec_hdr, int verbose);
933 int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
934 			struct ubi_ec_hdr *ec_hdr);
935 int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
936 			struct ubi_vid_io_buf *vidb, int verbose);
937 int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
938 			 struct ubi_vid_io_buf *vidb);
939 
940 /* build.c */
941 int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num,
942 		       int vid_hdr_offset, int max_beb_per1024);
943 int ubi_detach_mtd_dev(int ubi_num, int anyway);
944 struct ubi_device *ubi_get_device(int ubi_num);
945 void ubi_put_device(struct ubi_device *ubi);
946 struct ubi_device *ubi_get_by_major(int major);
947 int ubi_major2num(int major);
948 int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol,
949 		      int ntype);
950 int ubi_notify_all(struct ubi_device *ubi, int ntype,
951 		   struct notifier_block *nb);
952 int ubi_enumerate_volumes(struct notifier_block *nb);
953 void ubi_free_all_volumes(struct ubi_device *ubi);
954 void ubi_free_internal_volumes(struct ubi_device *ubi);
955 
956 /* kapi.c */
957 void ubi_do_get_device_info(struct ubi_device *ubi, struct ubi_device_info *di);
958 void ubi_do_get_volume_info(struct ubi_device *ubi, struct ubi_volume *vol,
959 			    struct ubi_volume_info *vi);
960 /* scan.c */
961 int ubi_compare_lebs(struct ubi_device *ubi, const struct ubi_ainf_peb *aeb,
962 		      int pnum, const struct ubi_vid_hdr *vid_hdr);
963 
964 /* fastmap.c */
965 #ifdef CONFIG_MTD_UBI_FASTMAP
966 size_t ubi_calc_fm_size(struct ubi_device *ubi);
967 int ubi_update_fastmap(struct ubi_device *ubi);
968 int ubi_scan_fastmap(struct ubi_device *ubi, struct ubi_attach_info *ai,
969 		     struct ubi_attach_info *scan_ai);
970 int ubi_fastmap_init_checkmap(struct ubi_volume *vol, int leb_count);
971 void ubi_fastmap_destroy_checkmap(struct ubi_volume *vol);
972 #else
ubi_update_fastmap(struct ubi_device * ubi)973 static inline int ubi_update_fastmap(struct ubi_device *ubi) { return 0; }
ubi_fastmap_init_checkmap(struct ubi_volume * vol,int leb_count)974 static inline int ubi_fastmap_init_checkmap(struct ubi_volume *vol, int leb_count) { return 0; }
ubi_fastmap_destroy_checkmap(struct ubi_volume * vol)975 static inline void ubi_fastmap_destroy_checkmap(struct ubi_volume *vol) {}
976 #endif
977 
978 /* block.c */
979 #ifdef CONFIG_MTD_UBI_BLOCK
980 int ubiblock_init(void);
981 void ubiblock_exit(void);
982 int ubiblock_create(struct ubi_volume_info *vi);
983 int ubiblock_remove(struct ubi_volume_info *vi);
984 #else
ubiblock_init(void)985 static inline int ubiblock_init(void) { return 0; }
ubiblock_exit(void)986 static inline void ubiblock_exit(void) {}
ubiblock_create(struct ubi_volume_info * vi)987 static inline int ubiblock_create(struct ubi_volume_info *vi)
988 {
989 	return -ENOSYS;
990 }
ubiblock_remove(struct ubi_volume_info * vi)991 static inline int ubiblock_remove(struct ubi_volume_info *vi)
992 {
993 	return -ENOSYS;
994 }
995 #endif
996 
997 /*
998  * ubi_for_each_free_peb - walk the UBI free RB tree.
999  * @ubi: UBI device description object
1000  * @e: a pointer to a ubi_wl_entry to use as cursor
1001  * @pos: a pointer to RB-tree entry type to use as a loop counter
1002  */
1003 #define ubi_for_each_free_peb(ubi, e, tmp_rb)	\
1004 	ubi_rb_for_each_entry((tmp_rb), (e), &(ubi)->free, u.rb)
1005 
1006 /*
1007  * ubi_for_each_used_peb - walk the UBI used RB tree.
1008  * @ubi: UBI device description object
1009  * @e: a pointer to a ubi_wl_entry to use as cursor
1010  * @pos: a pointer to RB-tree entry type to use as a loop counter
1011  */
1012 #define ubi_for_each_used_peb(ubi, e, tmp_rb)	\
1013 	ubi_rb_for_each_entry((tmp_rb), (e), &(ubi)->used, u.rb)
1014 
1015 /*
1016  * ubi_for_each_scub_peb - walk the UBI scub RB tree.
1017  * @ubi: UBI device description object
1018  * @e: a pointer to a ubi_wl_entry to use as cursor
1019  * @pos: a pointer to RB-tree entry type to use as a loop counter
1020  */
1021 #define ubi_for_each_scrub_peb(ubi, e, tmp_rb)	\
1022 	ubi_rb_for_each_entry((tmp_rb), (e), &(ubi)->scrub, u.rb)
1023 
1024 /*
1025  * ubi_for_each_protected_peb - walk the UBI protection queue.
1026  * @ubi: UBI device description object
1027  * @i: a integer used as counter
1028  * @e: a pointer to a ubi_wl_entry to use as cursor
1029  */
1030 #define ubi_for_each_protected_peb(ubi, i, e)	\
1031 	for ((i) = 0; (i) < UBI_PROT_QUEUE_LEN; (i)++)	\
1032 		list_for_each_entry((e), &(ubi->pq[(i)]), u.list)
1033 
1034 /*
1035  * ubi_rb_for_each_entry - walk an RB-tree.
1036  * @rb: a pointer to type 'struct rb_node' to use as a loop counter
1037  * @pos: a pointer to RB-tree entry type to use as a loop counter
1038  * @root: RB-tree's root
1039  * @member: the name of the 'struct rb_node' within the RB-tree entry
1040  */
1041 #define ubi_rb_for_each_entry(rb, pos, root, member)                         \
1042 	for (rb = rb_first(root),                                            \
1043 	     pos = (rb ? container_of(rb, typeof(*pos), member) : NULL);     \
1044 	     rb;                                                             \
1045 	     rb = rb_next(rb),                                               \
1046 	     pos = (rb ? container_of(rb, typeof(*pos), member) : NULL))
1047 
1048 /*
1049  * ubi_move_aeb_to_list - move a PEB from the volume tree to a list.
1050  *
1051  * @av: volume attaching information
1052  * @aeb: attaching eraseblock information
1053  * @list: the list to move to
1054  */
ubi_move_aeb_to_list(struct ubi_ainf_volume * av,struct ubi_ainf_peb * aeb,struct list_head * list)1055 static inline void ubi_move_aeb_to_list(struct ubi_ainf_volume *av,
1056 					 struct ubi_ainf_peb *aeb,
1057 					 struct list_head *list)
1058 {
1059 		rb_erase(&aeb->u.rb, &av->root);
1060 		list_add_tail(&aeb->u.list, list);
1061 }
1062 
1063 /**
1064  * ubi_init_vid_buf - Initialize a VID buffer
1065  * @ubi: the UBI device
1066  * @vidb: the VID buffer to initialize
1067  * @buf: the underlying buffer
1068  */
ubi_init_vid_buf(const struct ubi_device * ubi,struct ubi_vid_io_buf * vidb,void * buf)1069 static inline void ubi_init_vid_buf(const struct ubi_device *ubi,
1070 				    struct ubi_vid_io_buf *vidb,
1071 				    void *buf)
1072 {
1073 	if (buf)
1074 		memset(buf, 0, ubi->vid_hdr_alsize);
1075 
1076 	vidb->buffer = buf;
1077 	vidb->hdr = buf + ubi->vid_hdr_shift;
1078 }
1079 
1080 /**
1081  * ubi_init_vid_buf - Allocate a VID buffer
1082  * @ubi: the UBI device
1083  * @gfp_flags: GFP flags to use for the allocation
1084  */
1085 static inline struct ubi_vid_io_buf *
ubi_alloc_vid_buf(const struct ubi_device * ubi,gfp_t gfp_flags)1086 ubi_alloc_vid_buf(const struct ubi_device *ubi, gfp_t gfp_flags)
1087 {
1088 	struct ubi_vid_io_buf *vidb;
1089 	void *buf;
1090 
1091 	vidb = kzalloc(sizeof(*vidb), gfp_flags);
1092 	if (!vidb)
1093 		return NULL;
1094 
1095 	buf = kmalloc(ubi->vid_hdr_alsize, gfp_flags);
1096 	if (!buf) {
1097 		kfree(vidb);
1098 		return NULL;
1099 	}
1100 
1101 	ubi_init_vid_buf(ubi, vidb, buf);
1102 
1103 	return vidb;
1104 }
1105 
1106 /**
1107  * ubi_free_vid_buf - Free a VID buffer
1108  * @vidb: the VID buffer to free
1109  */
ubi_free_vid_buf(struct ubi_vid_io_buf * vidb)1110 static inline void ubi_free_vid_buf(struct ubi_vid_io_buf *vidb)
1111 {
1112 	if (!vidb)
1113 		return;
1114 
1115 	kfree(vidb->buffer);
1116 	kfree(vidb);
1117 }
1118 
1119 /**
1120  * ubi_get_vid_hdr - Get the VID header attached to a VID buffer
1121  * @vidb: VID buffer
1122  */
ubi_get_vid_hdr(struct ubi_vid_io_buf * vidb)1123 static inline struct ubi_vid_hdr *ubi_get_vid_hdr(struct ubi_vid_io_buf *vidb)
1124 {
1125 	return vidb->hdr;
1126 }
1127 
1128 /*
1129  * This function is equivalent to 'ubi_io_read()', but @offset is relative to
1130  * the beginning of the logical eraseblock, not to the beginning of the
1131  * physical eraseblock.
1132  */
ubi_io_read_data(const struct ubi_device * ubi,void * buf,int pnum,int offset,int len)1133 static inline int ubi_io_read_data(const struct ubi_device *ubi, void *buf,
1134 				   int pnum, int offset, int len)
1135 {
1136 	ubi_assert(offset >= 0);
1137 	return ubi_io_read(ubi, buf, pnum, offset + ubi->leb_start, len);
1138 }
1139 
1140 /*
1141  * This function is equivalent to 'ubi_io_write()', but @offset is relative to
1142  * the beginning of the logical eraseblock, not to the beginning of the
1143  * physical eraseblock.
1144  */
ubi_io_write_data(struct ubi_device * ubi,const void * buf,int pnum,int offset,int len)1145 static inline int ubi_io_write_data(struct ubi_device *ubi, const void *buf,
1146 				    int pnum, int offset, int len)
1147 {
1148 	ubi_assert(offset >= 0);
1149 	return ubi_io_write(ubi, buf, pnum, offset + ubi->leb_start, len);
1150 }
1151 
1152 /**
1153  * ubi_ro_mode - switch to read-only mode.
1154  * @ubi: UBI device description object
1155  */
ubi_ro_mode(struct ubi_device * ubi)1156 static inline void ubi_ro_mode(struct ubi_device *ubi)
1157 {
1158 	if (!ubi->ro_mode) {
1159 		ubi->ro_mode = 1;
1160 		ubi_warn(ubi, "switch to read-only mode");
1161 		dump_stack();
1162 	}
1163 }
1164 
1165 /**
1166  * vol_id2idx - get table index by volume ID.
1167  * @ubi: UBI device description object
1168  * @vol_id: volume ID
1169  */
vol_id2idx(const struct ubi_device * ubi,int vol_id)1170 static inline int vol_id2idx(const struct ubi_device *ubi, int vol_id)
1171 {
1172 	if (vol_id >= UBI_INTERNAL_VOL_START)
1173 		return vol_id - UBI_INTERNAL_VOL_START + ubi->vtbl_slots;
1174 	else
1175 		return vol_id;
1176 }
1177 
1178 /**
1179  * idx2vol_id - get volume ID by table index.
1180  * @ubi: UBI device description object
1181  * @idx: table index
1182  */
idx2vol_id(const struct ubi_device * ubi,int idx)1183 static inline int idx2vol_id(const struct ubi_device *ubi, int idx)
1184 {
1185 	if (idx >= ubi->vtbl_slots)
1186 		return idx - ubi->vtbl_slots + UBI_INTERNAL_VOL_START;
1187 	else
1188 		return idx;
1189 }
1190 
1191 /**
1192  * ubi_is_fm_vol - check whether a volume ID is a Fastmap volume.
1193  * @vol_id: volume ID
1194  */
ubi_is_fm_vol(int vol_id)1195 static inline bool ubi_is_fm_vol(int vol_id)
1196 {
1197 	switch (vol_id) {
1198 		case UBI_FM_SB_VOLUME_ID:
1199 		case UBI_FM_DATA_VOLUME_ID:
1200 		return true;
1201 	}
1202 
1203 	return false;
1204 }
1205 
1206 /**
1207  * ubi_find_fm_block - check whether a PEB is part of the current Fastmap.
1208  * @ubi: UBI device description object
1209  * @pnum: physical eraseblock to look for
1210  *
1211  * This function returns a wear leveling object if @pnum relates to the current
1212  * fastmap, @NULL otherwise.
1213  */
ubi_find_fm_block(const struct ubi_device * ubi,int pnum)1214 static inline struct ubi_wl_entry *ubi_find_fm_block(const struct ubi_device *ubi,
1215 						     int pnum)
1216 {
1217 	int i;
1218 
1219 	if (ubi->fm) {
1220 		for (i = 0; i < ubi->fm->used_blocks; i++) {
1221 			if (ubi->fm->e[i]->pnum == pnum)
1222 				return ubi->fm->e[i];
1223 		}
1224 	}
1225 
1226 	return NULL;
1227 }
1228 
1229 #endif /* !__UBI_UBI_H__ */
1230