12d262c48SKyungmin Park /* 22d262c48SKyungmin Park * Copyright (c) International Business Machines Corp., 2006 32d262c48SKyungmin Park * 41a459660SWolfgang Denk * SPDX-License-Identifier: GPL-2.0+ 52d262c48SKyungmin Park * 62d262c48SKyungmin Park * Author: Artem Bityutskiy (Битюцкий Артём) 72d262c48SKyungmin Park */ 82d262c48SKyungmin Park 92d262c48SKyungmin Park /* This file mostly implements UBI kernel API functions */ 102d262c48SKyungmin Park 11*ff94bc40SHeiko Schocher #define __UBOOT__ 12*ff94bc40SHeiko Schocher #ifndef __UBOOT__ 132d262c48SKyungmin Park #include <linux/module.h> 14*ff94bc40SHeiko Schocher #include <linux/slab.h> 15*ff94bc40SHeiko Schocher #include <linux/namei.h> 16*ff94bc40SHeiko Schocher #include <linux/fs.h> 172d262c48SKyungmin Park #include <asm/div64.h> 18*ff94bc40SHeiko Schocher #else 192d262c48SKyungmin Park #include <ubi_uboot.h> 20*ff94bc40SHeiko Schocher #endif 21*ff94bc40SHeiko Schocher #include <linux/err.h> 22*ff94bc40SHeiko Schocher 232d262c48SKyungmin Park #include "ubi.h" 242d262c48SKyungmin Park 252d262c48SKyungmin Park /** 26*ff94bc40SHeiko Schocher * ubi_do_get_device_info - get information about UBI device. 27*ff94bc40SHeiko Schocher * @ubi: UBI device description object 28*ff94bc40SHeiko Schocher * @di: the information is stored here 29*ff94bc40SHeiko Schocher * 30*ff94bc40SHeiko Schocher * This function is the same as 'ubi_get_device_info()', but it assumes the UBI 31*ff94bc40SHeiko Schocher * device is locked and cannot disappear. 32*ff94bc40SHeiko Schocher */ 33*ff94bc40SHeiko Schocher void ubi_do_get_device_info(struct ubi_device *ubi, struct ubi_device_info *di) 34*ff94bc40SHeiko Schocher { 35*ff94bc40SHeiko Schocher di->ubi_num = ubi->ubi_num; 36*ff94bc40SHeiko Schocher di->leb_size = ubi->leb_size; 37*ff94bc40SHeiko Schocher di->leb_start = ubi->leb_start; 38*ff94bc40SHeiko Schocher di->min_io_size = ubi->min_io_size; 39*ff94bc40SHeiko Schocher di->max_write_size = ubi->max_write_size; 40*ff94bc40SHeiko Schocher di->ro_mode = ubi->ro_mode; 41*ff94bc40SHeiko Schocher #ifndef __UBOOT__ 42*ff94bc40SHeiko Schocher di->cdev = ubi->cdev.dev; 43*ff94bc40SHeiko Schocher #endif 44*ff94bc40SHeiko Schocher } 45*ff94bc40SHeiko Schocher EXPORT_SYMBOL_GPL(ubi_do_get_device_info); 46*ff94bc40SHeiko Schocher 47*ff94bc40SHeiko Schocher /** 482d262c48SKyungmin Park * ubi_get_device_info - get information about UBI device. 492d262c48SKyungmin Park * @ubi_num: UBI device number 502d262c48SKyungmin Park * @di: the information is stored here 512d262c48SKyungmin Park * 522d262c48SKyungmin Park * This function returns %0 in case of success, %-EINVAL if the UBI device 532d262c48SKyungmin Park * number is invalid, and %-ENODEV if there is no such UBI device. 542d262c48SKyungmin Park */ 552d262c48SKyungmin Park int ubi_get_device_info(int ubi_num, struct ubi_device_info *di) 562d262c48SKyungmin Park { 572d262c48SKyungmin Park struct ubi_device *ubi; 582d262c48SKyungmin Park 592d262c48SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 602d262c48SKyungmin Park return -EINVAL; 612d262c48SKyungmin Park ubi = ubi_get_device(ubi_num); 622d262c48SKyungmin Park if (!ubi) 632d262c48SKyungmin Park return -ENODEV; 64*ff94bc40SHeiko Schocher ubi_do_get_device_info(ubi, di); 652d262c48SKyungmin Park ubi_put_device(ubi); 662d262c48SKyungmin Park return 0; 672d262c48SKyungmin Park } 682d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_get_device_info); 692d262c48SKyungmin Park 702d262c48SKyungmin Park /** 71*ff94bc40SHeiko Schocher * ubi_do_get_volume_info - get information about UBI volume. 72*ff94bc40SHeiko Schocher * @ubi: UBI device description object 73*ff94bc40SHeiko Schocher * @vol: volume description object 742d262c48SKyungmin Park * @vi: the information is stored here 752d262c48SKyungmin Park */ 76*ff94bc40SHeiko Schocher void ubi_do_get_volume_info(struct ubi_device *ubi, struct ubi_volume *vol, 772d262c48SKyungmin Park struct ubi_volume_info *vi) 782d262c48SKyungmin Park { 792d262c48SKyungmin Park vi->vol_id = vol->vol_id; 802d262c48SKyungmin Park vi->ubi_num = ubi->ubi_num; 812d262c48SKyungmin Park vi->size = vol->reserved_pebs; 822d262c48SKyungmin Park vi->used_bytes = vol->used_bytes; 832d262c48SKyungmin Park vi->vol_type = vol->vol_type; 842d262c48SKyungmin Park vi->corrupted = vol->corrupted; 852d262c48SKyungmin Park vi->upd_marker = vol->upd_marker; 862d262c48SKyungmin Park vi->alignment = vol->alignment; 872d262c48SKyungmin Park vi->usable_leb_size = vol->usable_leb_size; 882d262c48SKyungmin Park vi->name_len = vol->name_len; 892d262c48SKyungmin Park vi->name = vol->name; 902d262c48SKyungmin Park vi->cdev = vol->cdev.dev; 912d262c48SKyungmin Park } 92*ff94bc40SHeiko Schocher 93*ff94bc40SHeiko Schocher /** 94*ff94bc40SHeiko Schocher * ubi_get_volume_info - get information about UBI volume. 95*ff94bc40SHeiko Schocher * @desc: volume descriptor 96*ff94bc40SHeiko Schocher * @vi: the information is stored here 97*ff94bc40SHeiko Schocher */ 98*ff94bc40SHeiko Schocher void ubi_get_volume_info(struct ubi_volume_desc *desc, 99*ff94bc40SHeiko Schocher struct ubi_volume_info *vi) 100*ff94bc40SHeiko Schocher { 101*ff94bc40SHeiko Schocher ubi_do_get_volume_info(desc->vol->ubi, desc->vol, vi); 102*ff94bc40SHeiko Schocher } 1032d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_get_volume_info); 1042d262c48SKyungmin Park 1052d262c48SKyungmin Park /** 1062d262c48SKyungmin Park * ubi_open_volume - open UBI volume. 1072d262c48SKyungmin Park * @ubi_num: UBI device number 1082d262c48SKyungmin Park * @vol_id: volume ID 1092d262c48SKyungmin Park * @mode: open mode 1102d262c48SKyungmin Park * 1112d262c48SKyungmin Park * The @mode parameter specifies if the volume should be opened in read-only 1122d262c48SKyungmin Park * mode, read-write mode, or exclusive mode. The exclusive mode guarantees that 1132d262c48SKyungmin Park * nobody else will be able to open this volume. UBI allows to have many volume 1142d262c48SKyungmin Park * readers and one writer at a time. 1152d262c48SKyungmin Park * 1162d262c48SKyungmin Park * If a static volume is being opened for the first time since boot, it will be 1172d262c48SKyungmin Park * checked by this function, which means it will be fully read and the CRC 1182d262c48SKyungmin Park * checksum of each logical eraseblock will be checked. 1192d262c48SKyungmin Park * 1202d262c48SKyungmin Park * This function returns volume descriptor in case of success and a negative 1212d262c48SKyungmin Park * error code in case of failure. 1222d262c48SKyungmin Park */ 1232d262c48SKyungmin Park struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode) 1242d262c48SKyungmin Park { 1252d262c48SKyungmin Park int err; 1262d262c48SKyungmin Park struct ubi_volume_desc *desc; 1272d262c48SKyungmin Park struct ubi_device *ubi; 1282d262c48SKyungmin Park struct ubi_volume *vol; 1292d262c48SKyungmin Park 130*ff94bc40SHeiko Schocher dbg_gen("open device %d, volume %d, mode %d", ubi_num, vol_id, mode); 1312d262c48SKyungmin Park 1322d262c48SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 1332d262c48SKyungmin Park return ERR_PTR(-EINVAL); 1342d262c48SKyungmin Park 1352d262c48SKyungmin Park if (mode != UBI_READONLY && mode != UBI_READWRITE && 1362d262c48SKyungmin Park mode != UBI_EXCLUSIVE) 1372d262c48SKyungmin Park return ERR_PTR(-EINVAL); 1382d262c48SKyungmin Park 1392d262c48SKyungmin Park /* 1402d262c48SKyungmin Park * First of all, we have to get the UBI device to prevent its removal. 1412d262c48SKyungmin Park */ 1422d262c48SKyungmin Park ubi = ubi_get_device(ubi_num); 1432d262c48SKyungmin Park if (!ubi) 1442d262c48SKyungmin Park return ERR_PTR(-ENODEV); 1452d262c48SKyungmin Park 1462d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots) { 1472d262c48SKyungmin Park err = -EINVAL; 1482d262c48SKyungmin Park goto out_put_ubi; 1492d262c48SKyungmin Park } 1502d262c48SKyungmin Park 1512d262c48SKyungmin Park desc = kmalloc(sizeof(struct ubi_volume_desc), GFP_KERNEL); 1522d262c48SKyungmin Park if (!desc) { 1532d262c48SKyungmin Park err = -ENOMEM; 1542d262c48SKyungmin Park goto out_put_ubi; 1552d262c48SKyungmin Park } 1562d262c48SKyungmin Park 1572d262c48SKyungmin Park err = -ENODEV; 1582d262c48SKyungmin Park if (!try_module_get(THIS_MODULE)) 1592d262c48SKyungmin Park goto out_free; 1602d262c48SKyungmin Park 1612d262c48SKyungmin Park spin_lock(&ubi->volumes_lock); 1622d262c48SKyungmin Park vol = ubi->volumes[vol_id]; 1632d262c48SKyungmin Park if (!vol) 1642d262c48SKyungmin Park goto out_unlock; 1652d262c48SKyungmin Park 1662d262c48SKyungmin Park err = -EBUSY; 1672d262c48SKyungmin Park switch (mode) { 1682d262c48SKyungmin Park case UBI_READONLY: 1692d262c48SKyungmin Park if (vol->exclusive) 1702d262c48SKyungmin Park goto out_unlock; 1712d262c48SKyungmin Park vol->readers += 1; 1722d262c48SKyungmin Park break; 1732d262c48SKyungmin Park 1742d262c48SKyungmin Park case UBI_READWRITE: 1752d262c48SKyungmin Park if (vol->exclusive || vol->writers > 0) 1762d262c48SKyungmin Park goto out_unlock; 1772d262c48SKyungmin Park vol->writers += 1; 1782d262c48SKyungmin Park break; 1792d262c48SKyungmin Park 1802d262c48SKyungmin Park case UBI_EXCLUSIVE: 1812d262c48SKyungmin Park if (vol->exclusive || vol->writers || vol->readers) 1822d262c48SKyungmin Park goto out_unlock; 1832d262c48SKyungmin Park vol->exclusive = 1; 1842d262c48SKyungmin Park break; 1852d262c48SKyungmin Park } 1862d262c48SKyungmin Park get_device(&vol->dev); 1872d262c48SKyungmin Park vol->ref_count += 1; 1882d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 1892d262c48SKyungmin Park 1902d262c48SKyungmin Park desc->vol = vol; 1912d262c48SKyungmin Park desc->mode = mode; 1922d262c48SKyungmin Park 1932d262c48SKyungmin Park mutex_lock(&ubi->ckvol_mutex); 1942d262c48SKyungmin Park if (!vol->checked) { 1952d262c48SKyungmin Park /* This is the first open - check the volume */ 1962d262c48SKyungmin Park err = ubi_check_volume(ubi, vol_id); 1972d262c48SKyungmin Park if (err < 0) { 1982d262c48SKyungmin Park mutex_unlock(&ubi->ckvol_mutex); 1992d262c48SKyungmin Park ubi_close_volume(desc); 2002d262c48SKyungmin Park return ERR_PTR(err); 2012d262c48SKyungmin Park } 2022d262c48SKyungmin Park if (err == 1) { 2032d262c48SKyungmin Park ubi_warn("volume %d on UBI device %d is corrupted", 2042d262c48SKyungmin Park vol_id, ubi->ubi_num); 2052d262c48SKyungmin Park vol->corrupted = 1; 2062d262c48SKyungmin Park } 2072d262c48SKyungmin Park vol->checked = 1; 2082d262c48SKyungmin Park } 2092d262c48SKyungmin Park mutex_unlock(&ubi->ckvol_mutex); 2102d262c48SKyungmin Park 2112d262c48SKyungmin Park return desc; 2122d262c48SKyungmin Park 2132d262c48SKyungmin Park out_unlock: 2142d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 2152d262c48SKyungmin Park module_put(THIS_MODULE); 2162d262c48SKyungmin Park out_free: 2172d262c48SKyungmin Park kfree(desc); 2182d262c48SKyungmin Park out_put_ubi: 2192d262c48SKyungmin Park ubi_put_device(ubi); 220*ff94bc40SHeiko Schocher ubi_err("cannot open device %d, volume %d, error %d", 221*ff94bc40SHeiko Schocher ubi_num, vol_id, err); 2222d262c48SKyungmin Park return ERR_PTR(err); 2232d262c48SKyungmin Park } 2242d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_open_volume); 2252d262c48SKyungmin Park 2262d262c48SKyungmin Park /** 2272d262c48SKyungmin Park * ubi_open_volume_nm - open UBI volume by name. 2282d262c48SKyungmin Park * @ubi_num: UBI device number 2292d262c48SKyungmin Park * @name: volume name 2302d262c48SKyungmin Park * @mode: open mode 2312d262c48SKyungmin Park * 2322d262c48SKyungmin Park * This function is similar to 'ubi_open_volume()', but opens a volume by name. 2332d262c48SKyungmin Park */ 2342d262c48SKyungmin Park struct ubi_volume_desc *ubi_open_volume_nm(int ubi_num, const char *name, 2352d262c48SKyungmin Park int mode) 2362d262c48SKyungmin Park { 2372d262c48SKyungmin Park int i, vol_id = -1, len; 2382d262c48SKyungmin Park struct ubi_device *ubi; 2392d262c48SKyungmin Park struct ubi_volume_desc *ret; 2402d262c48SKyungmin Park 241*ff94bc40SHeiko Schocher dbg_gen("open device %d, volume %s, mode %d", ubi_num, name, mode); 2422d262c48SKyungmin Park 2432d262c48SKyungmin Park if (!name) 2442d262c48SKyungmin Park return ERR_PTR(-EINVAL); 2452d262c48SKyungmin Park 2462d262c48SKyungmin Park len = strnlen(name, UBI_VOL_NAME_MAX + 1); 2472d262c48SKyungmin Park if (len > UBI_VOL_NAME_MAX) 2482d262c48SKyungmin Park return ERR_PTR(-EINVAL); 2492d262c48SKyungmin Park 2502d262c48SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 2512d262c48SKyungmin Park return ERR_PTR(-EINVAL); 2522d262c48SKyungmin Park 2532d262c48SKyungmin Park ubi = ubi_get_device(ubi_num); 2542d262c48SKyungmin Park if (!ubi) 2552d262c48SKyungmin Park return ERR_PTR(-ENODEV); 2562d262c48SKyungmin Park 2572d262c48SKyungmin Park spin_lock(&ubi->volumes_lock); 2582d262c48SKyungmin Park /* Walk all volumes of this UBI device */ 2592d262c48SKyungmin Park for (i = 0; i < ubi->vtbl_slots; i++) { 2602d262c48SKyungmin Park struct ubi_volume *vol = ubi->volumes[i]; 2612d262c48SKyungmin Park 2622d262c48SKyungmin Park if (vol && len == vol->name_len && !strcmp(name, vol->name)) { 2632d262c48SKyungmin Park vol_id = i; 2642d262c48SKyungmin Park break; 2652d262c48SKyungmin Park } 2662d262c48SKyungmin Park } 2672d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 2682d262c48SKyungmin Park 2692d262c48SKyungmin Park if (vol_id >= 0) 2702d262c48SKyungmin Park ret = ubi_open_volume(ubi_num, vol_id, mode); 2712d262c48SKyungmin Park else 2722d262c48SKyungmin Park ret = ERR_PTR(-ENODEV); 2732d262c48SKyungmin Park 2742d262c48SKyungmin Park /* 2752d262c48SKyungmin Park * We should put the UBI device even in case of success, because 2762d262c48SKyungmin Park * 'ubi_open_volume()' took a reference as well. 2772d262c48SKyungmin Park */ 2782d262c48SKyungmin Park ubi_put_device(ubi); 2792d262c48SKyungmin Park return ret; 2802d262c48SKyungmin Park } 2812d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_open_volume_nm); 2822d262c48SKyungmin Park 283*ff94bc40SHeiko Schocher #ifndef __UBOOT__ 284*ff94bc40SHeiko Schocher /** 285*ff94bc40SHeiko Schocher * ubi_open_volume_path - open UBI volume by its character device node path. 286*ff94bc40SHeiko Schocher * @pathname: volume character device node path 287*ff94bc40SHeiko Schocher * @mode: open mode 288*ff94bc40SHeiko Schocher * 289*ff94bc40SHeiko Schocher * This function is similar to 'ubi_open_volume()', but opens a volume the path 290*ff94bc40SHeiko Schocher * to its character device node. 291*ff94bc40SHeiko Schocher */ 292*ff94bc40SHeiko Schocher struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode) 293*ff94bc40SHeiko Schocher { 294*ff94bc40SHeiko Schocher int error, ubi_num, vol_id, mod; 295*ff94bc40SHeiko Schocher struct inode *inode; 296*ff94bc40SHeiko Schocher struct path path; 297*ff94bc40SHeiko Schocher 298*ff94bc40SHeiko Schocher dbg_gen("open volume %s, mode %d", pathname, mode); 299*ff94bc40SHeiko Schocher 300*ff94bc40SHeiko Schocher if (!pathname || !*pathname) 301*ff94bc40SHeiko Schocher return ERR_PTR(-EINVAL); 302*ff94bc40SHeiko Schocher 303*ff94bc40SHeiko Schocher error = kern_path(pathname, LOOKUP_FOLLOW, &path); 304*ff94bc40SHeiko Schocher if (error) 305*ff94bc40SHeiko Schocher return ERR_PTR(error); 306*ff94bc40SHeiko Schocher 307*ff94bc40SHeiko Schocher inode = path.dentry->d_inode; 308*ff94bc40SHeiko Schocher mod = inode->i_mode; 309*ff94bc40SHeiko Schocher ubi_num = ubi_major2num(imajor(inode)); 310*ff94bc40SHeiko Schocher vol_id = iminor(inode) - 1; 311*ff94bc40SHeiko Schocher path_put(&path); 312*ff94bc40SHeiko Schocher 313*ff94bc40SHeiko Schocher if (!S_ISCHR(mod)) 314*ff94bc40SHeiko Schocher return ERR_PTR(-EINVAL); 315*ff94bc40SHeiko Schocher if (vol_id >= 0 && ubi_num >= 0) 316*ff94bc40SHeiko Schocher return ubi_open_volume(ubi_num, vol_id, mode); 317*ff94bc40SHeiko Schocher return ERR_PTR(-ENODEV); 318*ff94bc40SHeiko Schocher } 319*ff94bc40SHeiko Schocher EXPORT_SYMBOL_GPL(ubi_open_volume_path); 320*ff94bc40SHeiko Schocher #endif 321*ff94bc40SHeiko Schocher 3222d262c48SKyungmin Park /** 3232d262c48SKyungmin Park * ubi_close_volume - close UBI volume. 3242d262c48SKyungmin Park * @desc: volume descriptor 3252d262c48SKyungmin Park */ 3262d262c48SKyungmin Park void ubi_close_volume(struct ubi_volume_desc *desc) 3272d262c48SKyungmin Park { 3282d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 3292d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 3302d262c48SKyungmin Park 331*ff94bc40SHeiko Schocher dbg_gen("close device %d, volume %d, mode %d", 332*ff94bc40SHeiko Schocher ubi->ubi_num, vol->vol_id, desc->mode); 3332d262c48SKyungmin Park 3342d262c48SKyungmin Park spin_lock(&ubi->volumes_lock); 3352d262c48SKyungmin Park switch (desc->mode) { 3362d262c48SKyungmin Park case UBI_READONLY: 3372d262c48SKyungmin Park vol->readers -= 1; 3382d262c48SKyungmin Park break; 3392d262c48SKyungmin Park case UBI_READWRITE: 3402d262c48SKyungmin Park vol->writers -= 1; 3412d262c48SKyungmin Park break; 3422d262c48SKyungmin Park case UBI_EXCLUSIVE: 3432d262c48SKyungmin Park vol->exclusive = 0; 3442d262c48SKyungmin Park } 3452d262c48SKyungmin Park vol->ref_count -= 1; 3462d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 3472d262c48SKyungmin Park 3482d262c48SKyungmin Park kfree(desc); 3492d262c48SKyungmin Park put_device(&vol->dev); 3502d262c48SKyungmin Park ubi_put_device(ubi); 3512d262c48SKyungmin Park module_put(THIS_MODULE); 3522d262c48SKyungmin Park } 3532d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_close_volume); 3542d262c48SKyungmin Park 3552d262c48SKyungmin Park /** 3562d262c48SKyungmin Park * ubi_leb_read - read data. 3572d262c48SKyungmin Park * @desc: volume descriptor 3582d262c48SKyungmin Park * @lnum: logical eraseblock number to read from 3592d262c48SKyungmin Park * @buf: buffer where to store the read data 3602d262c48SKyungmin Park * @offset: offset within the logical eraseblock to read from 3612d262c48SKyungmin Park * @len: how many bytes to read 3622d262c48SKyungmin Park * @check: whether UBI has to check the read data's CRC or not. 3632d262c48SKyungmin Park * 3642d262c48SKyungmin Park * This function reads data from offset @offset of logical eraseblock @lnum and 3652d262c48SKyungmin Park * stores the data at @buf. When reading from static volumes, @check specifies 3662d262c48SKyungmin Park * whether the data has to be checked or not. If yes, the whole logical 3672d262c48SKyungmin Park * eraseblock will be read and its CRC checksum will be checked (i.e., the CRC 3682d262c48SKyungmin Park * checksum is per-eraseblock). So checking may substantially slow down the 3692d262c48SKyungmin Park * read speed. The @check argument is ignored for dynamic volumes. 3702d262c48SKyungmin Park * 3712d262c48SKyungmin Park * In case of success, this function returns zero. In case of failure, this 3722d262c48SKyungmin Park * function returns a negative error code. 3732d262c48SKyungmin Park * 3742d262c48SKyungmin Park * %-EBADMSG error code is returned: 3752d262c48SKyungmin Park * o for both static and dynamic volumes if MTD driver has detected a data 3762d262c48SKyungmin Park * integrity problem (unrecoverable ECC checksum mismatch in case of NAND); 3772d262c48SKyungmin Park * o for static volumes in case of data CRC mismatch. 3782d262c48SKyungmin Park * 3792d262c48SKyungmin Park * If the volume is damaged because of an interrupted update this function just 3802d262c48SKyungmin Park * returns immediately with %-EBADF error code. 3812d262c48SKyungmin Park */ 3822d262c48SKyungmin Park int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset, 3832d262c48SKyungmin Park int len, int check) 3842d262c48SKyungmin Park { 3852d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 3862d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 3872d262c48SKyungmin Park int err, vol_id = vol->vol_id; 3882d262c48SKyungmin Park 389*ff94bc40SHeiko Schocher dbg_gen("read %d bytes from LEB %d:%d:%d", len, vol_id, lnum, offset); 3902d262c48SKyungmin Park 3912d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots || lnum < 0 || 3922d262c48SKyungmin Park lnum >= vol->used_ebs || offset < 0 || len < 0 || 3932d262c48SKyungmin Park offset + len > vol->usable_leb_size) 3942d262c48SKyungmin Park return -EINVAL; 3952d262c48SKyungmin Park 3962d262c48SKyungmin Park if (vol->vol_type == UBI_STATIC_VOLUME) { 3972d262c48SKyungmin Park if (vol->used_ebs == 0) 3982d262c48SKyungmin Park /* Empty static UBI volume */ 3992d262c48SKyungmin Park return 0; 4002d262c48SKyungmin Park if (lnum == vol->used_ebs - 1 && 4012d262c48SKyungmin Park offset + len > vol->last_eb_bytes) 4022d262c48SKyungmin Park return -EINVAL; 4032d262c48SKyungmin Park } 4042d262c48SKyungmin Park 4052d262c48SKyungmin Park if (vol->upd_marker) 4062d262c48SKyungmin Park return -EBADF; 4072d262c48SKyungmin Park if (len == 0) 4082d262c48SKyungmin Park return 0; 4092d262c48SKyungmin Park 4102d262c48SKyungmin Park err = ubi_eba_read_leb(ubi, vol, lnum, buf, offset, len, check); 411dfe64e2cSSergey Lapin if (err && mtd_is_eccerr(err) && vol->vol_type == UBI_STATIC_VOLUME) { 4122d262c48SKyungmin Park ubi_warn("mark volume %d as corrupted", vol_id); 4132d262c48SKyungmin Park vol->corrupted = 1; 4142d262c48SKyungmin Park } 4152d262c48SKyungmin Park 4162d262c48SKyungmin Park return err; 4172d262c48SKyungmin Park } 4182d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_read); 4192d262c48SKyungmin Park 4202d262c48SKyungmin Park /** 4212d262c48SKyungmin Park * ubi_leb_write - write data. 4222d262c48SKyungmin Park * @desc: volume descriptor 4232d262c48SKyungmin Park * @lnum: logical eraseblock number to write to 4242d262c48SKyungmin Park * @buf: data to write 4252d262c48SKyungmin Park * @offset: offset within the logical eraseblock where to write 4262d262c48SKyungmin Park * @len: how many bytes to write 4272d262c48SKyungmin Park * 4282d262c48SKyungmin Park * This function writes @len bytes of data from @buf to offset @offset of 429*ff94bc40SHeiko Schocher * logical eraseblock @lnum. 4302d262c48SKyungmin Park * 4312d262c48SKyungmin Park * This function takes care of physical eraseblock write failures. If write to 4322d262c48SKyungmin Park * the physical eraseblock write operation fails, the logical eraseblock is 4332d262c48SKyungmin Park * re-mapped to another physical eraseblock, the data is recovered, and the 4342d262c48SKyungmin Park * write finishes. UBI has a pool of reserved physical eraseblocks for this. 4352d262c48SKyungmin Park * 4362d262c48SKyungmin Park * If all the data were successfully written, zero is returned. If an error 4372d262c48SKyungmin Park * occurred and UBI has not been able to recover from it, this function returns 4382d262c48SKyungmin Park * a negative error code. Note, in case of an error, it is possible that 4392d262c48SKyungmin Park * something was still written to the flash media, but that may be some 4402d262c48SKyungmin Park * garbage. 4412d262c48SKyungmin Park * 4422d262c48SKyungmin Park * If the volume is damaged because of an interrupted update this function just 4432d262c48SKyungmin Park * returns immediately with %-EBADF code. 4442d262c48SKyungmin Park */ 4452d262c48SKyungmin Park int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf, 446*ff94bc40SHeiko Schocher int offset, int len) 4472d262c48SKyungmin Park { 4482d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 4492d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 4502d262c48SKyungmin Park int vol_id = vol->vol_id; 4512d262c48SKyungmin Park 452*ff94bc40SHeiko Schocher dbg_gen("write %d bytes to LEB %d:%d:%d", len, vol_id, lnum, offset); 4532d262c48SKyungmin Park 4542d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots) 4552d262c48SKyungmin Park return -EINVAL; 4562d262c48SKyungmin Park 4572d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 4582d262c48SKyungmin Park return -EROFS; 4592d262c48SKyungmin Park 4602d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs || offset < 0 || len < 0 || 4612d262c48SKyungmin Park offset + len > vol->usable_leb_size || 4622d262c48SKyungmin Park offset & (ubi->min_io_size - 1) || len & (ubi->min_io_size - 1)) 4632d262c48SKyungmin Park return -EINVAL; 4642d262c48SKyungmin Park 4652d262c48SKyungmin Park if (vol->upd_marker) 4662d262c48SKyungmin Park return -EBADF; 4672d262c48SKyungmin Park 4682d262c48SKyungmin Park if (len == 0) 4692d262c48SKyungmin Park return 0; 4702d262c48SKyungmin Park 471*ff94bc40SHeiko Schocher return ubi_eba_write_leb(ubi, vol, lnum, buf, offset, len); 4722d262c48SKyungmin Park } 4732d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_write); 4742d262c48SKyungmin Park 4752d262c48SKyungmin Park /* 4762d262c48SKyungmin Park * ubi_leb_change - change logical eraseblock atomically. 4772d262c48SKyungmin Park * @desc: volume descriptor 4782d262c48SKyungmin Park * @lnum: logical eraseblock number to change 4792d262c48SKyungmin Park * @buf: data to write 4802d262c48SKyungmin Park * @len: how many bytes to write 4812d262c48SKyungmin Park * 4822d262c48SKyungmin Park * This function changes the contents of a logical eraseblock atomically. @buf 4832d262c48SKyungmin Park * has to contain new logical eraseblock data, and @len - the length of the 484*ff94bc40SHeiko Schocher * data, which has to be aligned. The length may be shorter than the logical 4852d262c48SKyungmin Park * eraseblock size, ant the logical eraseblock may be appended to more times 4862d262c48SKyungmin Park * later on. This function guarantees that in case of an unclean reboot the old 4872d262c48SKyungmin Park * contents is preserved. Returns zero in case of success and a negative error 4882d262c48SKyungmin Park * code in case of failure. 4892d262c48SKyungmin Park */ 4902d262c48SKyungmin Park int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf, 491*ff94bc40SHeiko Schocher int len) 4922d262c48SKyungmin Park { 4932d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 4942d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 4952d262c48SKyungmin Park int vol_id = vol->vol_id; 4962d262c48SKyungmin Park 497*ff94bc40SHeiko Schocher dbg_gen("atomically write %d bytes to LEB %d:%d", len, vol_id, lnum); 4982d262c48SKyungmin Park 4992d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots) 5002d262c48SKyungmin Park return -EINVAL; 5012d262c48SKyungmin Park 5022d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 5032d262c48SKyungmin Park return -EROFS; 5042d262c48SKyungmin Park 5052d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs || len < 0 || 5062d262c48SKyungmin Park len > vol->usable_leb_size || len & (ubi->min_io_size - 1)) 5072d262c48SKyungmin Park return -EINVAL; 5082d262c48SKyungmin Park 5092d262c48SKyungmin Park if (vol->upd_marker) 5102d262c48SKyungmin Park return -EBADF; 5112d262c48SKyungmin Park 5122d262c48SKyungmin Park if (len == 0) 5132d262c48SKyungmin Park return 0; 5142d262c48SKyungmin Park 515*ff94bc40SHeiko Schocher return ubi_eba_atomic_leb_change(ubi, vol, lnum, buf, len); 5162d262c48SKyungmin Park } 5172d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_change); 5182d262c48SKyungmin Park 5192d262c48SKyungmin Park /** 5202d262c48SKyungmin Park * ubi_leb_erase - erase logical eraseblock. 5212d262c48SKyungmin Park * @desc: volume descriptor 5222d262c48SKyungmin Park * @lnum: logical eraseblock number 5232d262c48SKyungmin Park * 5242d262c48SKyungmin Park * This function un-maps logical eraseblock @lnum and synchronously erases the 5252d262c48SKyungmin Park * correspondent physical eraseblock. Returns zero in case of success and a 5262d262c48SKyungmin Park * negative error code in case of failure. 5272d262c48SKyungmin Park * 5282d262c48SKyungmin Park * If the volume is damaged because of an interrupted update this function just 5292d262c48SKyungmin Park * returns immediately with %-EBADF code. 5302d262c48SKyungmin Park */ 5312d262c48SKyungmin Park int ubi_leb_erase(struct ubi_volume_desc *desc, int lnum) 5322d262c48SKyungmin Park { 5332d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 5342d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 5352d262c48SKyungmin Park int err; 5362d262c48SKyungmin Park 537*ff94bc40SHeiko Schocher dbg_gen("erase LEB %d:%d", vol->vol_id, lnum); 5382d262c48SKyungmin Park 5392d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 5402d262c48SKyungmin Park return -EROFS; 5412d262c48SKyungmin Park 5422d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 5432d262c48SKyungmin Park return -EINVAL; 5442d262c48SKyungmin Park 5452d262c48SKyungmin Park if (vol->upd_marker) 5462d262c48SKyungmin Park return -EBADF; 5472d262c48SKyungmin Park 5482d262c48SKyungmin Park err = ubi_eba_unmap_leb(ubi, vol, lnum); 5492d262c48SKyungmin Park if (err) 5502d262c48SKyungmin Park return err; 5512d262c48SKyungmin Park 552*ff94bc40SHeiko Schocher return ubi_wl_flush(ubi, vol->vol_id, lnum); 5532d262c48SKyungmin Park } 5542d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_erase); 5552d262c48SKyungmin Park 5562d262c48SKyungmin Park /** 5572d262c48SKyungmin Park * ubi_leb_unmap - un-map logical eraseblock. 5582d262c48SKyungmin Park * @desc: volume descriptor 5592d262c48SKyungmin Park * @lnum: logical eraseblock number 5602d262c48SKyungmin Park * 5612d262c48SKyungmin Park * This function un-maps logical eraseblock @lnum and schedules the 5622d262c48SKyungmin Park * corresponding physical eraseblock for erasure, so that it will eventually be 563*ff94bc40SHeiko Schocher * physically erased in background. This operation is much faster than the 5642d262c48SKyungmin Park * erase operation. 5652d262c48SKyungmin Park * 5662d262c48SKyungmin Park * Unlike erase, the un-map operation does not guarantee that the logical 5672d262c48SKyungmin Park * eraseblock will contain all 0xFF bytes when UBI is initialized again. For 5682d262c48SKyungmin Park * example, if several logical eraseblocks are un-mapped, and an unclean reboot 5692d262c48SKyungmin Park * happens after this, the logical eraseblocks will not necessarily be 5702d262c48SKyungmin Park * un-mapped again when this MTD device is attached. They may actually be 5712d262c48SKyungmin Park * mapped to the same physical eraseblocks again. So, this function has to be 5722d262c48SKyungmin Park * used with care. 5732d262c48SKyungmin Park * 5742d262c48SKyungmin Park * In other words, when un-mapping a logical eraseblock, UBI does not store 5752d262c48SKyungmin Park * any information about this on the flash media, it just marks the logical 5762d262c48SKyungmin Park * eraseblock as "un-mapped" in RAM. If UBI is detached before the physical 5772d262c48SKyungmin Park * eraseblock is physically erased, it will be mapped again to the same logical 5782d262c48SKyungmin Park * eraseblock when the MTD device is attached again. 5792d262c48SKyungmin Park * 5802d262c48SKyungmin Park * The main and obvious use-case of this function is when the contents of a 5812d262c48SKyungmin Park * logical eraseblock has to be re-written. Then it is much more efficient to 582*ff94bc40SHeiko Schocher * first un-map it, then write new data, rather than first erase it, then write 5832d262c48SKyungmin Park * new data. Note, once new data has been written to the logical eraseblock, 5842d262c48SKyungmin Park * UBI guarantees that the old contents has gone forever. In other words, if an 5852d262c48SKyungmin Park * unclean reboot happens after the logical eraseblock has been un-mapped and 5862d262c48SKyungmin Park * then written to, it will contain the last written data. 5872d262c48SKyungmin Park * 5882d262c48SKyungmin Park * This function returns zero in case of success and a negative error code in 5892d262c48SKyungmin Park * case of failure. If the volume is damaged because of an interrupted update 5902d262c48SKyungmin Park * this function just returns immediately with %-EBADF code. 5912d262c48SKyungmin Park */ 5922d262c48SKyungmin Park int ubi_leb_unmap(struct ubi_volume_desc *desc, int lnum) 5932d262c48SKyungmin Park { 5942d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 5952d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 5962d262c48SKyungmin Park 597*ff94bc40SHeiko Schocher dbg_gen("unmap LEB %d:%d", vol->vol_id, lnum); 5982d262c48SKyungmin Park 5992d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 6002d262c48SKyungmin Park return -EROFS; 6012d262c48SKyungmin Park 6022d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 6032d262c48SKyungmin Park return -EINVAL; 6042d262c48SKyungmin Park 6052d262c48SKyungmin Park if (vol->upd_marker) 6062d262c48SKyungmin Park return -EBADF; 6072d262c48SKyungmin Park 6082d262c48SKyungmin Park return ubi_eba_unmap_leb(ubi, vol, lnum); 6092d262c48SKyungmin Park } 6102d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_unmap); 6112d262c48SKyungmin Park 6122d262c48SKyungmin Park /** 613*ff94bc40SHeiko Schocher * ubi_leb_map - map logical eraseblock to a physical eraseblock. 6142d262c48SKyungmin Park * @desc: volume descriptor 6152d262c48SKyungmin Park * @lnum: logical eraseblock number 6162d262c48SKyungmin Park * 6172d262c48SKyungmin Park * This function maps an un-mapped logical eraseblock @lnum to a physical 618*ff94bc40SHeiko Schocher * eraseblock. This means, that after a successful invocation of this 6192d262c48SKyungmin Park * function the logical eraseblock @lnum will be empty (contain only %0xFF 6202d262c48SKyungmin Park * bytes) and be mapped to a physical eraseblock, even if an unclean reboot 6212d262c48SKyungmin Park * happens. 6222d262c48SKyungmin Park * 6232d262c48SKyungmin Park * This function returns zero in case of success, %-EBADF if the volume is 6242d262c48SKyungmin Park * damaged because of an interrupted update, %-EBADMSG if the logical 6252d262c48SKyungmin Park * eraseblock is already mapped, and other negative error codes in case of 6262d262c48SKyungmin Park * other failures. 6272d262c48SKyungmin Park */ 628*ff94bc40SHeiko Schocher int ubi_leb_map(struct ubi_volume_desc *desc, int lnum) 6292d262c48SKyungmin Park { 6302d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 6312d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 6322d262c48SKyungmin Park 633*ff94bc40SHeiko Schocher dbg_gen("unmap LEB %d:%d", vol->vol_id, lnum); 6342d262c48SKyungmin Park 6352d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 6362d262c48SKyungmin Park return -EROFS; 6372d262c48SKyungmin Park 6382d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 6392d262c48SKyungmin Park return -EINVAL; 6402d262c48SKyungmin Park 6412d262c48SKyungmin Park if (vol->upd_marker) 6422d262c48SKyungmin Park return -EBADF; 6432d262c48SKyungmin Park 6442d262c48SKyungmin Park if (vol->eba_tbl[lnum] >= 0) 6452d262c48SKyungmin Park return -EBADMSG; 6462d262c48SKyungmin Park 647*ff94bc40SHeiko Schocher return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0); 6482d262c48SKyungmin Park } 6492d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_map); 6502d262c48SKyungmin Park 6512d262c48SKyungmin Park /** 6522d262c48SKyungmin Park * ubi_is_mapped - check if logical eraseblock is mapped. 6532d262c48SKyungmin Park * @desc: volume descriptor 6542d262c48SKyungmin Park * @lnum: logical eraseblock number 6552d262c48SKyungmin Park * 6562d262c48SKyungmin Park * This function checks if logical eraseblock @lnum is mapped to a physical 6572d262c48SKyungmin Park * eraseblock. If a logical eraseblock is un-mapped, this does not necessarily 6582d262c48SKyungmin Park * mean it will still be un-mapped after the UBI device is re-attached. The 6592d262c48SKyungmin Park * logical eraseblock may become mapped to the physical eraseblock it was last 6602d262c48SKyungmin Park * mapped to. 6612d262c48SKyungmin Park * 6622d262c48SKyungmin Park * This function returns %1 if the LEB is mapped, %0 if not, and a negative 6632d262c48SKyungmin Park * error code in case of failure. If the volume is damaged because of an 6642d262c48SKyungmin Park * interrupted update this function just returns immediately with %-EBADF error 6652d262c48SKyungmin Park * code. 6662d262c48SKyungmin Park */ 6672d262c48SKyungmin Park int ubi_is_mapped(struct ubi_volume_desc *desc, int lnum) 6682d262c48SKyungmin Park { 6692d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 6702d262c48SKyungmin Park 671*ff94bc40SHeiko Schocher dbg_gen("test LEB %d:%d", vol->vol_id, lnum); 6722d262c48SKyungmin Park 6732d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 6742d262c48SKyungmin Park return -EINVAL; 6752d262c48SKyungmin Park 6762d262c48SKyungmin Park if (vol->upd_marker) 6772d262c48SKyungmin Park return -EBADF; 6782d262c48SKyungmin Park 6792d262c48SKyungmin Park return vol->eba_tbl[lnum] >= 0; 6802d262c48SKyungmin Park } 6812d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_is_mapped); 682*ff94bc40SHeiko Schocher 683*ff94bc40SHeiko Schocher /** 684*ff94bc40SHeiko Schocher * ubi_sync - synchronize UBI device buffers. 685*ff94bc40SHeiko Schocher * @ubi_num: UBI device to synchronize 686*ff94bc40SHeiko Schocher * 687*ff94bc40SHeiko Schocher * The underlying MTD device may cache data in hardware or in software. This 688*ff94bc40SHeiko Schocher * function ensures the caches are flushed. Returns zero in case of success and 689*ff94bc40SHeiko Schocher * a negative error code in case of failure. 690*ff94bc40SHeiko Schocher */ 691*ff94bc40SHeiko Schocher int ubi_sync(int ubi_num) 692*ff94bc40SHeiko Schocher { 693*ff94bc40SHeiko Schocher struct ubi_device *ubi; 694*ff94bc40SHeiko Schocher 695*ff94bc40SHeiko Schocher ubi = ubi_get_device(ubi_num); 696*ff94bc40SHeiko Schocher if (!ubi) 697*ff94bc40SHeiko Schocher return -ENODEV; 698*ff94bc40SHeiko Schocher 699*ff94bc40SHeiko Schocher mtd_sync(ubi->mtd); 700*ff94bc40SHeiko Schocher ubi_put_device(ubi); 701*ff94bc40SHeiko Schocher return 0; 702*ff94bc40SHeiko Schocher } 703*ff94bc40SHeiko Schocher EXPORT_SYMBOL_GPL(ubi_sync); 704*ff94bc40SHeiko Schocher 705*ff94bc40SHeiko Schocher /** 706*ff94bc40SHeiko Schocher * ubi_flush - flush UBI work queue. 707*ff94bc40SHeiko Schocher * @ubi_num: UBI device to flush work queue 708*ff94bc40SHeiko Schocher * @vol_id: volume id to flush for 709*ff94bc40SHeiko Schocher * @lnum: logical eraseblock number to flush for 710*ff94bc40SHeiko Schocher * 711*ff94bc40SHeiko Schocher * This function executes all pending works for a particular volume id / logical 712*ff94bc40SHeiko Schocher * eraseblock number pair. If either value is set to %UBI_ALL, then it acts as 713*ff94bc40SHeiko Schocher * a wildcard for all of the corresponding volume numbers or logical 714*ff94bc40SHeiko Schocher * eraseblock numbers. It returns zero in case of success and a negative error 715*ff94bc40SHeiko Schocher * code in case of failure. 716*ff94bc40SHeiko Schocher */ 717*ff94bc40SHeiko Schocher int ubi_flush(int ubi_num, int vol_id, int lnum) 718*ff94bc40SHeiko Schocher { 719*ff94bc40SHeiko Schocher struct ubi_device *ubi; 720*ff94bc40SHeiko Schocher int err = 0; 721*ff94bc40SHeiko Schocher 722*ff94bc40SHeiko Schocher ubi = ubi_get_device(ubi_num); 723*ff94bc40SHeiko Schocher if (!ubi) 724*ff94bc40SHeiko Schocher return -ENODEV; 725*ff94bc40SHeiko Schocher 726*ff94bc40SHeiko Schocher err = ubi_wl_flush(ubi, vol_id, lnum); 727*ff94bc40SHeiko Schocher ubi_put_device(ubi); 728*ff94bc40SHeiko Schocher return err; 729*ff94bc40SHeiko Schocher } 730*ff94bc40SHeiko Schocher EXPORT_SYMBOL_GPL(ubi_flush); 731*ff94bc40SHeiko Schocher 732*ff94bc40SHeiko Schocher #ifndef __UBOOT__ 733*ff94bc40SHeiko Schocher BLOCKING_NOTIFIER_HEAD(ubi_notifiers); 734*ff94bc40SHeiko Schocher 735*ff94bc40SHeiko Schocher /** 736*ff94bc40SHeiko Schocher * ubi_register_volume_notifier - register a volume notifier. 737*ff94bc40SHeiko Schocher * @nb: the notifier description object 738*ff94bc40SHeiko Schocher * @ignore_existing: if non-zero, do not send "added" notification for all 739*ff94bc40SHeiko Schocher * already existing volumes 740*ff94bc40SHeiko Schocher * 741*ff94bc40SHeiko Schocher * This function registers a volume notifier, which means that 742*ff94bc40SHeiko Schocher * 'nb->notifier_call()' will be invoked when an UBI volume is created, 743*ff94bc40SHeiko Schocher * removed, re-sized, re-named, or updated. The first argument of the function 744*ff94bc40SHeiko Schocher * is the notification type. The second argument is pointer to a 745*ff94bc40SHeiko Schocher * &struct ubi_notification object which describes the notification event. 746*ff94bc40SHeiko Schocher * Using UBI API from the volume notifier is prohibited. 747*ff94bc40SHeiko Schocher * 748*ff94bc40SHeiko Schocher * This function returns zero in case of success and a negative error code 749*ff94bc40SHeiko Schocher * in case of failure. 750*ff94bc40SHeiko Schocher */ 751*ff94bc40SHeiko Schocher int ubi_register_volume_notifier(struct notifier_block *nb, 752*ff94bc40SHeiko Schocher int ignore_existing) 753*ff94bc40SHeiko Schocher { 754*ff94bc40SHeiko Schocher int err; 755*ff94bc40SHeiko Schocher 756*ff94bc40SHeiko Schocher err = blocking_notifier_chain_register(&ubi_notifiers, nb); 757*ff94bc40SHeiko Schocher if (err != 0) 758*ff94bc40SHeiko Schocher return err; 759*ff94bc40SHeiko Schocher if (ignore_existing) 760*ff94bc40SHeiko Schocher return 0; 761*ff94bc40SHeiko Schocher 762*ff94bc40SHeiko Schocher /* 763*ff94bc40SHeiko Schocher * We are going to walk all UBI devices and all volumes, and 764*ff94bc40SHeiko Schocher * notify the user about existing volumes by the %UBI_VOLUME_ADDED 765*ff94bc40SHeiko Schocher * event. We have to lock the @ubi_devices_mutex to make sure UBI 766*ff94bc40SHeiko Schocher * devices do not disappear. 767*ff94bc40SHeiko Schocher */ 768*ff94bc40SHeiko Schocher mutex_lock(&ubi_devices_mutex); 769*ff94bc40SHeiko Schocher ubi_enumerate_volumes(nb); 770*ff94bc40SHeiko Schocher mutex_unlock(&ubi_devices_mutex); 771*ff94bc40SHeiko Schocher 772*ff94bc40SHeiko Schocher return err; 773*ff94bc40SHeiko Schocher } 774*ff94bc40SHeiko Schocher EXPORT_SYMBOL_GPL(ubi_register_volume_notifier); 775*ff94bc40SHeiko Schocher 776*ff94bc40SHeiko Schocher /** 777*ff94bc40SHeiko Schocher * ubi_unregister_volume_notifier - unregister the volume notifier. 778*ff94bc40SHeiko Schocher * @nb: the notifier description object 779*ff94bc40SHeiko Schocher * 780*ff94bc40SHeiko Schocher * This function unregisters volume notifier @nm and returns zero in case of 781*ff94bc40SHeiko Schocher * success and a negative error code in case of failure. 782*ff94bc40SHeiko Schocher */ 783*ff94bc40SHeiko Schocher int ubi_unregister_volume_notifier(struct notifier_block *nb) 784*ff94bc40SHeiko Schocher { 785*ff94bc40SHeiko Schocher return blocking_notifier_chain_unregister(&ubi_notifiers, nb); 786*ff94bc40SHeiko Schocher } 787*ff94bc40SHeiko Schocher EXPORT_SYMBOL_GPL(ubi_unregister_volume_notifier); 788*ff94bc40SHeiko Schocher #endif 789