linux-imx

// SPDX-License-Identifier: GPL-2.0

#include <linux/capability.h>

#include <linux/blkdev.h>

#include <linux/export.h>

#include <linux/gfp.h>

#include <linux/blkpg.h>

#include <linux/hdreg.h>

#include <linux/backing-dev.h>

#include <linux/fs.h>

#include <linux/blktrace_api.h>

#include <linux/pr.h>

#include <linux/uaccess.h>

​

static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user *arg)

{

    struct block_device *bdevp;

    struct gendisk *disk;

    struct hd_struct *part, *lpart;

    struct blkpg_ioctl_arg a;

    struct blkpg_partition p;

    struct disk_part_iter piter;

    long long start, length;

    int partno;

​

    if (!capable(CAP_SYS_ADMIN))

        return -EACCES;

    if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg)))

        return -EFAULT;

    if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))

        return -EFAULT;

    disk = bdev->bd_disk;

    if (bdev != bdev->bd_contains)

        return -EINVAL;

    partno = p.pno;

    if (partno <= 0)

        return -EINVAL;

    switch (a.op) {

        case BLKPG_ADD_PARTITION:

            start = p.start >> 9;

            length = p.length >> 9;

            /* check for fit in a hd_struct */

            if (sizeof(sector_t) == sizeof(long) &&

                sizeof(long long) > sizeof(long)) {

                long pstart = start, plength = length;

                if (pstart != start || plength != length

                    || pstart < 0 || plength < 0 || partno > 65535)

                    return -EINVAL;

            }

            /* check if partition is aligned to blocksize */

            if (p.start & (bdev_logical_block_size(bdev) - 1))

                return -EINVAL;

​

            mutex_lock(&bdev->bd_mutex);

​

            /* overlap? */

            disk_part_iter_init(&piter, disk,

                        DISK_PITER_INCL_EMPTY);

            while ((part = disk_part_iter_next(&piter))) {

                if (!(start + length <= part->start_sect ||

                      start >= part->start_sect + part->nr_sects)) {

                    disk_part_iter_exit(&piter);

                    mutex_unlock(&bdev->bd_mutex);

                    return -EBUSY;

                }

            }

            disk_part_iter_exit(&piter);

​

            /* all seems OK */

            part = add_partition(disk, partno, start, length,

                         ADDPART_FLAG_NONE, NULL);

            mutex_unlock(&bdev->bd_mutex);

            return PTR_ERR_OR_ZERO(part);

        case BLKPG_DEL_PARTITION:

            part = disk_get_part(disk, partno);

            if (!part)

                return -ENXIO;

​

            bdevp = bdget(part_devt(part));

            disk_put_part(part);

            if (!bdevp)

                return -ENOMEM;

​

            mutex_lock(&bdevp->bd_mutex);

            if (bdevp->bd_openers) {

                mutex_unlock(&bdevp->bd_mutex);

                bdput(bdevp);

                return -EBUSY;

            }

            /* all seems OK */

            fsync_bdev(bdevp);

            invalidate_bdev(bdevp);

​