xref: /openbmc/linux/drivers/mtd/ubi/cdev.c (revision d7a3d85e)
1  /*
2   * Copyright (c) International Business Machines Corp., 2006
3   *
4   * This program is free software; you can redistribute it and/or modify
5   * it under the terms of the GNU General Public License as published by
6   * the Free Software Foundation; either version 2 of the License, or
7   * (at your option) any later version.
8   *
9   * This program is distributed in the hope that it will be useful,
10   * but WITHOUT ANY WARRANTY; without even the implied warranty of
11   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12   * the GNU General Public License for more details.
13   *
14   * You should have received a copy of the GNU General Public License
15   * along with this program; if not, write to the Free Software
16   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17   *
18   * Author: Artem Bityutskiy (Битюцкий Артём)
19   */
20  
21  /*
22   * This file includes implementation of UBI character device operations.
23   *
24   * There are two kinds of character devices in UBI: UBI character devices and
25   * UBI volume character devices. UBI character devices allow users to
26   * manipulate whole volumes: create, remove, and re-size them. Volume character
27   * devices provide volume I/O capabilities.
28   *
29   * Major and minor numbers are assigned dynamically to both UBI and volume
30   * character devices.
31   *
32   * Well, there is the third kind of character devices - the UBI control
33   * character device, which allows to manipulate by UBI devices - create and
34   * delete them. In other words, it is used for attaching and detaching MTD
35   * devices.
36   */
37  
38  #include <linux/module.h>
39  #include <linux/stat.h>
40  #include <linux/slab.h>
41  #include <linux/ioctl.h>
42  #include <linux/capability.h>
43  #include <linux/uaccess.h>
44  #include <linux/compat.h>
45  #include <linux/math64.h>
46  #include <mtd/ubi-user.h>
47  #include "ubi.h"
48  
49  /**
50   * get_exclusive - get exclusive access to an UBI volume.
51   * @desc: volume descriptor
52   *
53   * This function changes UBI volume open mode to "exclusive". Returns previous
54   * mode value (positive integer) in case of success and a negative error code
55   * in case of failure.
56   */
57  static int get_exclusive(struct ubi_volume_desc *desc)
58  {
59  	int users, err;
60  	struct ubi_volume *vol = desc->vol;
61  
62  	spin_lock(&vol->ubi->volumes_lock);
63  	users = vol->readers + vol->writers + vol->exclusive + vol->metaonly;
64  	ubi_assert(users > 0);
65  	if (users > 1) {
66  		ubi_err(vol->ubi, "%d users for volume %d", users, vol->vol_id);
67  		err = -EBUSY;
68  	} else {
69  		vol->readers = vol->writers = vol->metaonly = 0;
70  		vol->exclusive = 1;
71  		err = desc->mode;
72  		desc->mode = UBI_EXCLUSIVE;
73  	}
74  	spin_unlock(&vol->ubi->volumes_lock);
75  
76  	return err;
77  }
78  
79  /**
80   * revoke_exclusive - revoke exclusive mode.
81   * @desc: volume descriptor
82   * @mode: new mode to switch to
83   */
84  static void revoke_exclusive(struct ubi_volume_desc *desc, int mode)
85  {
86  	struct ubi_volume *vol = desc->vol;
87  
88  	spin_lock(&vol->ubi->volumes_lock);
89  	ubi_assert(vol->readers == 0 && vol->writers == 0 && vol->metaonly == 0);
90  	ubi_assert(vol->exclusive == 1 && desc->mode == UBI_EXCLUSIVE);
91  	vol->exclusive = 0;
92  	if (mode == UBI_READONLY)
93  		vol->readers = 1;
94  	else if (mode == UBI_READWRITE)
95  		vol->writers = 1;
96  	else if (mode == UBI_METAONLY)
97  		vol->metaonly = 1;
98  	else
99  		vol->exclusive = 1;
100  	spin_unlock(&vol->ubi->volumes_lock);
101  
102  	desc->mode = mode;
103  }
104  
105  static int vol_cdev_open(struct inode *inode, struct file *file)
106  {
107  	struct ubi_volume_desc *desc;
108  	int vol_id = iminor(inode) - 1, mode, ubi_num;
109  
110  	ubi_num = ubi_major2num(imajor(inode));
111  	if (ubi_num < 0)
112  		return ubi_num;
113  
114  	if (file->f_mode & FMODE_WRITE)
115  		mode = UBI_READWRITE;
116  	else
117  		mode = UBI_READONLY;
118  
119  	dbg_gen("open device %d, volume %d, mode %d",
120  		ubi_num, vol_id, mode);
121  
122  	desc = ubi_open_volume(ubi_num, vol_id, mode);
123  	if (IS_ERR(desc))
124  		return PTR_ERR(desc);
125  
126  	file->private_data = desc;
127  	return 0;
128  }
129  
130  static int vol_cdev_release(struct inode *inode, struct file *file)
131  {
132  	struct ubi_volume_desc *desc = file->private_data;
133  	struct ubi_volume *vol = desc->vol;
134  
135  	dbg_gen("release device %d, volume %d, mode %d",
136  		vol->ubi->ubi_num, vol->vol_id, desc->mode);
137  
138  	if (vol->updating) {
139  		ubi_warn(vol->ubi, "update of volume %d not finished, volume is damaged",
140  			 vol->vol_id);
141  		ubi_assert(!vol->changing_leb);
142  		vol->updating = 0;
143  		vfree(vol->upd_buf);
144  	} else if (vol->changing_leb) {
145  		dbg_gen("only %lld of %lld bytes received for atomic LEB change for volume %d:%d, cancel",
146  			vol->upd_received, vol->upd_bytes, vol->ubi->ubi_num,
147  			vol->vol_id);
148  		vol->changing_leb = 0;
149  		vfree(vol->upd_buf);
150  	}
151  
152  	ubi_close_volume(desc);
153  	return 0;
154  }
155  
156  static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin)
157  {
158  	struct ubi_volume_desc *desc = file->private_data;
159  	struct ubi_volume *vol = desc->vol;
160  
161  	if (vol->updating) {
162  		/* Update is in progress, seeking is prohibited */
163  		ubi_err(vol->ubi, "updating");
164  		return -EBUSY;
165  	}
166  
167  	return fixed_size_llseek(file, offset, origin, vol->used_bytes);
168  }
169  
170  static int vol_cdev_fsync(struct file *file, loff_t start, loff_t end,
171  			  int datasync)
172  {
173  	struct ubi_volume_desc *desc = file->private_data;
174  	struct ubi_device *ubi = desc->vol->ubi;
175  	struct inode *inode = file_inode(file);
176  	int err;
177  	mutex_lock(&inode->i_mutex);
178  	err = ubi_sync(ubi->ubi_num);
179  	mutex_unlock(&inode->i_mutex);
180  	return err;
181  }
182  
183  
184  static ssize_t vol_cdev_read(struct file *file, __user char *buf, size_t count,
185  			     loff_t *offp)
186  {
187  	struct ubi_volume_desc *desc = file->private_data;
188  	struct ubi_volume *vol = desc->vol;
189  	struct ubi_device *ubi = vol->ubi;
190  	int err, lnum, off, len,  tbuf_size;
191  	size_t count_save = count;
192  	void *tbuf;
193  
194  	dbg_gen("read %zd bytes from offset %lld of volume %d",
195  		count, *offp, vol->vol_id);
196  
197  	if (vol->updating) {
198  		ubi_err(vol->ubi, "updating");
199  		return -EBUSY;
200  	}
201  	if (vol->upd_marker) {
202  		ubi_err(vol->ubi, "damaged volume, update marker is set");
203  		return -EBADF;
204  	}
205  	if (*offp == vol->used_bytes || count == 0)
206  		return 0;
207  
208  	if (vol->corrupted)
209  		dbg_gen("read from corrupted volume %d", vol->vol_id);
210  
211  	if (*offp + count > vol->used_bytes)
212  		count_save = count = vol->used_bytes - *offp;
213  
214  	tbuf_size = vol->usable_leb_size;
215  	if (count < tbuf_size)
216  		tbuf_size = ALIGN(count, ubi->min_io_size);
217  	tbuf = vmalloc(tbuf_size);
218  	if (!tbuf)
219  		return -ENOMEM;
220  
221  	len = count > tbuf_size ? tbuf_size : count;
222  	lnum = div_u64_rem(*offp, vol->usable_leb_size, &off);
223  
224  	do {
225  		cond_resched();
226  
227  		if (off + len >= vol->usable_leb_size)
228  			len = vol->usable_leb_size - off;
229  
230  		err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0);
231  		if (err)
232  			break;
233  
234  		off += len;
235  		if (off == vol->usable_leb_size) {
236  			lnum += 1;
237  			off -= vol->usable_leb_size;
238  		}
239  
240  		count -= len;
241  		*offp += len;
242  
243  		err = copy_to_user(buf, tbuf, len);
244  		if (err) {
245  			err = -EFAULT;
246  			break;
247  		}
248  
249  		buf += len;
250  		len = count > tbuf_size ? tbuf_size : count;
251  	} while (count);
252  
253  	vfree(tbuf);
254  	return err ? err : count_save - count;
255  }
256  
257  /*
258   * This function allows to directly write to dynamic UBI volumes, without
259   * issuing the volume update operation.
260   */
261  static ssize_t vol_cdev_direct_write(struct file *file, const char __user *buf,
262  				     size_t count, loff_t *offp)
263  {
264  	struct ubi_volume_desc *desc = file->private_data;
265  	struct ubi_volume *vol = desc->vol;
266  	struct ubi_device *ubi = vol->ubi;
267  	int lnum, off, len, tbuf_size, err = 0;
268  	size_t count_save = count;
269  	char *tbuf;
270  
271  	if (!vol->direct_writes)
272  		return -EPERM;
273  
274  	dbg_gen("requested: write %zd bytes to offset %lld of volume %u",
275  		count, *offp, vol->vol_id);
276  
277  	if (vol->vol_type == UBI_STATIC_VOLUME)
278  		return -EROFS;
279  
280  	lnum = div_u64_rem(*offp, vol->usable_leb_size, &off);
281  	if (off & (ubi->min_io_size - 1)) {
282  		ubi_err(ubi, "unaligned position");
283  		return -EINVAL;
284  	}
285  
286  	if (*offp + count > vol->used_bytes)
287  		count_save = count = vol->used_bytes - *offp;
288  
289  	/* We can write only in fractions of the minimum I/O unit */
290  	if (count & (ubi->min_io_size - 1)) {
291  		ubi_err(ubi, "unaligned write length");
292  		return -EINVAL;
293  	}
294  
295  	tbuf_size = vol->usable_leb_size;
296  	if (count < tbuf_size)
297  		tbuf_size = ALIGN(count, ubi->min_io_size);
298  	tbuf = vmalloc(tbuf_size);
299  	if (!tbuf)
300  		return -ENOMEM;
301  
302  	len = count > tbuf_size ? tbuf_size : count;
303  
304  	while (count) {
305  		cond_resched();
306  
307  		if (off + len >= vol->usable_leb_size)
308  			len = vol->usable_leb_size - off;
309  
310  		err = copy_from_user(tbuf, buf, len);
311  		if (err) {
312  			err = -EFAULT;
313  			break;
314  		}
315  
316  		err = ubi_eba_write_leb(ubi, vol, lnum, tbuf, off, len);
317  		if (err)
318  			break;
319  
320  		off += len;
321  		if (off == vol->usable_leb_size) {
322  			lnum += 1;
323  			off -= vol->usable_leb_size;
324  		}
325  
326  		count -= len;
327  		*offp += len;
328  		buf += len;
329  		len = count > tbuf_size ? tbuf_size : count;
330  	}
331  
332  	vfree(tbuf);
333  	return err ? err : count_save - count;
334  }
335  
336  static ssize_t vol_cdev_write(struct file *file, const char __user *buf,
337  			      size_t count, loff_t *offp)
338  {
339  	int err = 0;
340  	struct ubi_volume_desc *desc = file->private_data;
341  	struct ubi_volume *vol = desc->vol;
342  	struct ubi_device *ubi = vol->ubi;
343  
344  	if (!vol->updating && !vol->changing_leb)
345  		return vol_cdev_direct_write(file, buf, count, offp);
346  
347  	if (vol->updating)
348  		err = ubi_more_update_data(ubi, vol, buf, count);
349  	else
350  		err = ubi_more_leb_change_data(ubi, vol, buf, count);
351  
352  	if (err < 0) {
353  		ubi_err(ubi, "cannot accept more %zd bytes of data, error %d",
354  			count, err);
355  		return err;
356  	}
357  
358  	if (err) {
359  		/*
360  		 * The operation is finished, @err contains number of actually
361  		 * written bytes.
362  		 */
363  		count = err;
364  
365  		if (vol->changing_leb) {
366  			revoke_exclusive(desc, UBI_READWRITE);
367  			return count;
368  		}
369  
370  		err = ubi_check_volume(ubi, vol->vol_id);
371  		if (err < 0)
372  			return err;
373  
374  		if (err) {
375  			ubi_warn(ubi, "volume %d on UBI device %d is corrupted",
376  				 vol->vol_id, ubi->ubi_num);
377  			vol->corrupted = 1;
378  		}
379  		vol->checked = 1;
380  		ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED);
381  		revoke_exclusive(desc, UBI_READWRITE);
382  	}
383  
384  	return count;
385  }
386  
387  static long vol_cdev_ioctl(struct file *file, unsigned int cmd,
388  			   unsigned long arg)
389  {
390  	int err = 0;
391  	struct ubi_volume_desc *desc = file->private_data;
392  	struct ubi_volume *vol = desc->vol;
393  	struct ubi_device *ubi = vol->ubi;
394  	void __user *argp = (void __user *)arg;
395  
396  	switch (cmd) {
397  	/* Volume update command */
398  	case UBI_IOCVOLUP:
399  	{
400  		int64_t bytes, rsvd_bytes;
401  
402  		if (!capable(CAP_SYS_RESOURCE)) {
403  			err = -EPERM;
404  			break;
405  		}
406  
407  		err = copy_from_user(&bytes, argp, sizeof(int64_t));
408  		if (err) {
409  			err = -EFAULT;
410  			break;
411  		}
412  
413  		if (desc->mode == UBI_READONLY) {
414  			err = -EROFS;
415  			break;
416  		}
417  
418  		rsvd_bytes = (long long)vol->reserved_pebs *
419  					ubi->leb_size-vol->data_pad;
420  		if (bytes < 0 || bytes > rsvd_bytes) {
421  			err = -EINVAL;
422  			break;
423  		}
424  
425  		err = get_exclusive(desc);
426  		if (err < 0)
427  			break;
428  
429  		err = ubi_start_update(ubi, vol, bytes);
430  		if (bytes == 0) {
431  			ubi_volume_notify(ubi, vol, UBI_VOLUME_UPDATED);
432  			revoke_exclusive(desc, UBI_READWRITE);
433  		}
434  		break;
435  	}
436  
437  	/* Atomic logical eraseblock change command */
438  	case UBI_IOCEBCH:
439  	{
440  		struct ubi_leb_change_req req;
441  
442  		err = copy_from_user(&req, argp,
443  				     sizeof(struct ubi_leb_change_req));
444  		if (err) {
445  			err = -EFAULT;
446  			break;
447  		}
448  
449  		if (desc->mode == UBI_READONLY ||
450  		    vol->vol_type == UBI_STATIC_VOLUME) {
451  			err = -EROFS;
452  			break;
453  		}
454  
455  		/* Validate the request */
456  		err = -EINVAL;
457  		if (req.lnum < 0 || req.lnum >= vol->reserved_pebs ||
458  		    req.bytes < 0 || req.bytes > vol->usable_leb_size)
459  			break;
460  
461  		err = get_exclusive(desc);
462  		if (err < 0)
463  			break;
464  
465  		err = ubi_start_leb_change(ubi, vol, &req);
466  		if (req.bytes == 0)
467  			revoke_exclusive(desc, UBI_READWRITE);
468  		break;
469  	}
470  
471  	/* Logical eraseblock erasure command */
472  	case UBI_IOCEBER:
473  	{
474  		int32_t lnum;
475  
476  		err = get_user(lnum, (__user int32_t *)argp);
477  		if (err) {
478  			err = -EFAULT;
479  			break;
480  		}
481  
482  		if (desc->mode == UBI_READONLY ||
483  		    vol->vol_type == UBI_STATIC_VOLUME) {
484  			err = -EROFS;
485  			break;
486  		}
487  
488  		if (lnum < 0 || lnum >= vol->reserved_pebs) {
489  			err = -EINVAL;
490  			break;
491  		}
492  
493  		dbg_gen("erase LEB %d:%d", vol->vol_id, lnum);
494  		err = ubi_eba_unmap_leb(ubi, vol, lnum);
495  		if (err)
496  			break;
497  
498  		err = ubi_wl_flush(ubi, UBI_ALL, UBI_ALL);
499  		break;
500  	}
501  
502  	/* Logical eraseblock map command */
503  	case UBI_IOCEBMAP:
504  	{
505  		struct ubi_map_req req;
506  
507  		err = copy_from_user(&req, argp, sizeof(struct ubi_map_req));
508  		if (err) {
509  			err = -EFAULT;
510  			break;
511  		}
512  		err = ubi_leb_map(desc, req.lnum);
513  		break;
514  	}
515  
516  	/* Logical eraseblock un-map command */
517  	case UBI_IOCEBUNMAP:
518  	{
519  		int32_t lnum;
520  
521  		err = get_user(lnum, (__user int32_t *)argp);
522  		if (err) {
523  			err = -EFAULT;
524  			break;
525  		}
526  		err = ubi_leb_unmap(desc, lnum);
527  		break;
528  	}
529  
530  	/* Check if logical eraseblock is mapped command */
531  	case UBI_IOCEBISMAP:
532  	{
533  		int32_t lnum;
534  
535  		err = get_user(lnum, (__user int32_t *)argp);
536  		if (err) {
537  			err = -EFAULT;
538  			break;
539  		}
540  		err = ubi_is_mapped(desc, lnum);
541  		break;
542  	}
543  
544  	/* Set volume property command */
545  	case UBI_IOCSETVOLPROP:
546  	{
547  		struct ubi_set_vol_prop_req req;
548  
549  		err = copy_from_user(&req, argp,
550  				     sizeof(struct ubi_set_vol_prop_req));
551  		if (err) {
552  			err = -EFAULT;
553  			break;
554  		}
555  		switch (req.property) {
556  		case UBI_VOL_PROP_DIRECT_WRITE:
557  			mutex_lock(&ubi->device_mutex);
558  			desc->vol->direct_writes = !!req.value;
559  			mutex_unlock(&ubi->device_mutex);
560  			break;
561  		default:
562  			err = -EINVAL;
563  			break;
564  		}
565  		break;
566  	}
567  
568  	/* Create a R/O block device on top of the UBI volume */
569  	case UBI_IOCVOLCRBLK:
570  	{
571  		struct ubi_volume_info vi;
572  
573  		ubi_get_volume_info(desc, &vi);
574  		err = ubiblock_create(&vi);
575  		break;
576  	}
577  
578  	/* Remove the R/O block device */
579  	case UBI_IOCVOLRMBLK:
580  	{
581  		struct ubi_volume_info vi;
582  
583  		ubi_get_volume_info(desc, &vi);
584  		err = ubiblock_remove(&vi);
585  		break;
586  	}
587  
588  	default:
589  		err = -ENOTTY;
590  		break;
591  	}
592  	return err;
593  }
594  
595  /**
596   * verify_mkvol_req - verify volume creation request.
597   * @ubi: UBI device description object
598   * @req: the request to check
599   *
600   * This function zero if the request is correct, and %-EINVAL if not.
601   */
602  static int verify_mkvol_req(const struct ubi_device *ubi,
603  			    const struct ubi_mkvol_req *req)
604  {
605  	int n, err = -EINVAL;
606  
607  	if (req->bytes < 0 || req->alignment < 0 || req->vol_type < 0 ||
608  	    req->name_len < 0)
609  		goto bad;
610  
611  	if ((req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots) &&
612  	    req->vol_id != UBI_VOL_NUM_AUTO)
613  		goto bad;
614  
615  	if (req->alignment == 0)
616  		goto bad;
617  
618  	if (req->bytes == 0)
619  		goto bad;
620  
621  	if (req->vol_type != UBI_DYNAMIC_VOLUME &&
622  	    req->vol_type != UBI_STATIC_VOLUME)
623  		goto bad;
624  
625  	if (req->alignment > ubi->leb_size)
626  		goto bad;
627  
628  	n = req->alignment & (ubi->min_io_size - 1);
629  	if (req->alignment != 1 && n)
630  		goto bad;
631  
632  	if (!req->name[0] || !req->name_len)
633  		goto bad;
634  
635  	if (req->name_len > UBI_VOL_NAME_MAX) {
636  		err = -ENAMETOOLONG;
637  		goto bad;
638  	}
639  
640  	n = strnlen(req->name, req->name_len + 1);
641  	if (n != req->name_len)
642  		goto bad;
643  
644  	return 0;
645  
646  bad:
647  	ubi_err(ubi, "bad volume creation request");
648  	ubi_dump_mkvol_req(req);
649  	return err;
650  }
651  
652  /**
653   * verify_rsvol_req - verify volume re-size request.
654   * @ubi: UBI device description object
655   * @req: the request to check
656   *
657   * This function returns zero if the request is correct, and %-EINVAL if not.
658   */
659  static int verify_rsvol_req(const struct ubi_device *ubi,
660  			    const struct ubi_rsvol_req *req)
661  {
662  	if (req->bytes <= 0)
663  		return -EINVAL;
664  
665  	if (req->vol_id < 0 || req->vol_id >= ubi->vtbl_slots)
666  		return -EINVAL;
667  
668  	return 0;
669  }
670  
671  /**
672   * rename_volumes - rename UBI volumes.
673   * @ubi: UBI device description object
674   * @req: volumes re-name request
675   *
676   * This is a helper function for the volume re-name IOCTL which validates the
677   * the request, opens the volume and calls corresponding volumes management
678   * function. Returns zero in case of success and a negative error code in case
679   * of failure.
680   */
681  static int rename_volumes(struct ubi_device *ubi,
682  			  struct ubi_rnvol_req *req)
683  {
684  	int i, n, err;
685  	struct list_head rename_list;
686  	struct ubi_rename_entry *re, *re1;
687  
688  	if (req->count < 0 || req->count > UBI_MAX_RNVOL)
689  		return -EINVAL;
690  
691  	if (req->count == 0)
692  		return 0;
693  
694  	/* Validate volume IDs and names in the request */
695  	for (i = 0; i < req->count; i++) {
696  		if (req->ents[i].vol_id < 0 ||
697  		    req->ents[i].vol_id >= ubi->vtbl_slots)
698  			return -EINVAL;
699  		if (req->ents[i].name_len < 0)
700  			return -EINVAL;
701  		if (req->ents[i].name_len > UBI_VOL_NAME_MAX)
702  			return -ENAMETOOLONG;
703  		req->ents[i].name[req->ents[i].name_len] = '\0';
704  		n = strlen(req->ents[i].name);
705  		if (n != req->ents[i].name_len)
706  			return -EINVAL;
707  	}
708  
709  	/* Make sure volume IDs and names are unique */
710  	for (i = 0; i < req->count - 1; i++) {
711  		for (n = i + 1; n < req->count; n++) {
712  			if (req->ents[i].vol_id == req->ents[n].vol_id) {
713  				ubi_err(ubi, "duplicated volume id %d",
714  					req->ents[i].vol_id);
715  				return -EINVAL;
716  			}
717  			if (!strcmp(req->ents[i].name, req->ents[n].name)) {
718  				ubi_err(ubi, "duplicated volume name \"%s\"",
719  					req->ents[i].name);
720  				return -EINVAL;
721  			}
722  		}
723  	}
724  
725  	/* Create the re-name list */
726  	INIT_LIST_HEAD(&rename_list);
727  	for (i = 0; i < req->count; i++) {
728  		int vol_id = req->ents[i].vol_id;
729  		int name_len = req->ents[i].name_len;
730  		const char *name = req->ents[i].name;
731  
732  		re = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL);
733  		if (!re) {
734  			err = -ENOMEM;
735  			goto out_free;
736  		}
737  
738  		re->desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_METAONLY);
739  		if (IS_ERR(re->desc)) {
740  			err = PTR_ERR(re->desc);
741  			ubi_err(ubi, "cannot open volume %d, error %d",
742  				vol_id, err);
743  			kfree(re);
744  			goto out_free;
745  		}
746  
747  		/* Skip this re-naming if the name does not really change */
748  		if (re->desc->vol->name_len == name_len &&
749  		    !memcmp(re->desc->vol->name, name, name_len)) {
750  			ubi_close_volume(re->desc);
751  			kfree(re);
752  			continue;
753  		}
754  
755  		re->new_name_len = name_len;
756  		memcpy(re->new_name, name, name_len);
757  		list_add_tail(&re->list, &rename_list);
758  		dbg_gen("will rename volume %d from \"%s\" to \"%s\"",
759  			vol_id, re->desc->vol->name, name);
760  	}
761  
762  	if (list_empty(&rename_list))
763  		return 0;
764  
765  	/* Find out the volumes which have to be removed */
766  	list_for_each_entry(re, &rename_list, list) {
767  		struct ubi_volume_desc *desc;
768  		int no_remove_needed = 0;
769  
770  		/*
771  		 * Volume @re->vol_id is going to be re-named to
772  		 * @re->new_name, while its current name is @name. If a volume
773  		 * with name @re->new_name currently exists, it has to be
774  		 * removed, unless it is also re-named in the request (@req).
775  		 */
776  		list_for_each_entry(re1, &rename_list, list) {
777  			if (re->new_name_len == re1->desc->vol->name_len &&
778  			    !memcmp(re->new_name, re1->desc->vol->name,
779  				    re1->desc->vol->name_len)) {
780  				no_remove_needed = 1;
781  				break;
782  			}
783  		}
784  
785  		if (no_remove_needed)
786  			continue;
787  
788  		/*
789  		 * It seems we need to remove volume with name @re->new_name,
790  		 * if it exists.
791  		 */
792  		desc = ubi_open_volume_nm(ubi->ubi_num, re->new_name,
793  					  UBI_EXCLUSIVE);
794  		if (IS_ERR(desc)) {
795  			err = PTR_ERR(desc);
796  			if (err == -ENODEV)
797  				/* Re-naming into a non-existing volume name */
798  				continue;
799  
800  			/* The volume exists but busy, or an error occurred */
801  			ubi_err(ubi, "cannot open volume \"%s\", error %d",
802  				re->new_name, err);
803  			goto out_free;
804  		}
805  
806  		re1 = kzalloc(sizeof(struct ubi_rename_entry), GFP_KERNEL);
807  		if (!re1) {
808  			err = -ENOMEM;
809  			ubi_close_volume(desc);
810  			goto out_free;
811  		}
812  
813  		re1->remove = 1;
814  		re1->desc = desc;
815  		list_add(&re1->list, &rename_list);
816  		dbg_gen("will remove volume %d, name \"%s\"",
817  			re1->desc->vol->vol_id, re1->desc->vol->name);
818  	}
819  
820  	mutex_lock(&ubi->device_mutex);
821  	err = ubi_rename_volumes(ubi, &rename_list);
822  	mutex_unlock(&ubi->device_mutex);
823  
824  out_free:
825  	list_for_each_entry_safe(re, re1, &rename_list, list) {
826  		ubi_close_volume(re->desc);
827  		list_del(&re->list);
828  		kfree(re);
829  	}
830  	return err;
831  }
832  
833  static long ubi_cdev_ioctl(struct file *file, unsigned int cmd,
834  			   unsigned long arg)
835  {
836  	int err = 0;
837  	struct ubi_device *ubi;
838  	struct ubi_volume_desc *desc;
839  	void __user *argp = (void __user *)arg;
840  
841  	if (!capable(CAP_SYS_RESOURCE))
842  		return -EPERM;
843  
844  	ubi = ubi_get_by_major(imajor(file->f_mapping->host));
845  	if (!ubi)
846  		return -ENODEV;
847  
848  	switch (cmd) {
849  	/* Create volume command */
850  	case UBI_IOCMKVOL:
851  	{
852  		struct ubi_mkvol_req req;
853  
854  		dbg_gen("create volume");
855  		err = copy_from_user(&req, argp, sizeof(struct ubi_mkvol_req));
856  		if (err) {
857  			err = -EFAULT;
858  			break;
859  		}
860  
861  		err = verify_mkvol_req(ubi, &req);
862  		if (err)
863  			break;
864  
865  		mutex_lock(&ubi->device_mutex);
866  		err = ubi_create_volume(ubi, &req);
867  		mutex_unlock(&ubi->device_mutex);
868  		if (err)
869  			break;
870  
871  		err = put_user(req.vol_id, (__user int32_t *)argp);
872  		if (err)
873  			err = -EFAULT;
874  
875  		break;
876  	}
877  
878  	/* Remove volume command */
879  	case UBI_IOCRMVOL:
880  	{
881  		int vol_id;
882  
883  		dbg_gen("remove volume");
884  		err = get_user(vol_id, (__user int32_t *)argp);
885  		if (err) {
886  			err = -EFAULT;
887  			break;
888  		}
889  
890  		desc = ubi_open_volume(ubi->ubi_num, vol_id, UBI_EXCLUSIVE);
891  		if (IS_ERR(desc)) {
892  			err = PTR_ERR(desc);
893  			break;
894  		}
895  
896  		mutex_lock(&ubi->device_mutex);
897  		err = ubi_remove_volume(desc, 0);
898  		mutex_unlock(&ubi->device_mutex);
899  
900  		/*
901  		 * The volume is deleted (unless an error occurred), and the
902  		 * 'struct ubi_volume' object will be freed when
903  		 * 'ubi_close_volume()' will call 'put_device()'.
904  		 */
905  		ubi_close_volume(desc);
906  		break;
907  	}
908  
909  	/* Re-size volume command */
910  	case UBI_IOCRSVOL:
911  	{
912  		int pebs;
913  		struct ubi_rsvol_req req;
914  
915  		dbg_gen("re-size volume");
916  		err = copy_from_user(&req, argp, sizeof(struct ubi_rsvol_req));
917  		if (err) {
918  			err = -EFAULT;
919  			break;
920  		}
921  
922  		err = verify_rsvol_req(ubi, &req);
923  		if (err)
924  			break;
925  
926  		desc = ubi_open_volume(ubi->ubi_num, req.vol_id, UBI_EXCLUSIVE);
927  		if (IS_ERR(desc)) {
928  			err = PTR_ERR(desc);
929  			break;
930  		}
931  
932  		pebs = div_u64(req.bytes + desc->vol->usable_leb_size - 1,
933  			       desc->vol->usable_leb_size);
934  
935  		mutex_lock(&ubi->device_mutex);
936  		err = ubi_resize_volume(desc, pebs);
937  		mutex_unlock(&ubi->device_mutex);
938  		ubi_close_volume(desc);
939  		break;
940  	}
941  
942  	/* Re-name volumes command */
943  	case UBI_IOCRNVOL:
944  	{
945  		struct ubi_rnvol_req *req;
946  
947  		dbg_gen("re-name volumes");
948  		req = kmalloc(sizeof(struct ubi_rnvol_req), GFP_KERNEL);
949  		if (!req) {
950  			err = -ENOMEM;
951  			break;
952  		};
953  
954  		err = copy_from_user(req, argp, sizeof(struct ubi_rnvol_req));
955  		if (err) {
956  			err = -EFAULT;
957  			kfree(req);
958  			break;
959  		}
960  
961  		err = rename_volumes(ubi, req);
962  		kfree(req);
963  		break;
964  	}
965  
966  	default:
967  		err = -ENOTTY;
968  		break;
969  	}
970  
971  	ubi_put_device(ubi);
972  	return err;
973  }
974  
975  static long ctrl_cdev_ioctl(struct file *file, unsigned int cmd,
976  			    unsigned long arg)
977  {
978  	int err = 0;
979  	void __user *argp = (void __user *)arg;
980  
981  	if (!capable(CAP_SYS_RESOURCE))
982  		return -EPERM;
983  
984  	switch (cmd) {
985  	/* Attach an MTD device command */
986  	case UBI_IOCATT:
987  	{
988  		struct ubi_attach_req req;
989  		struct mtd_info *mtd;
990  
991  		dbg_gen("attach MTD device");
992  		err = copy_from_user(&req, argp, sizeof(struct ubi_attach_req));
993  		if (err) {
994  			err = -EFAULT;
995  			break;
996  		}
997  
998  		if (req.mtd_num < 0 ||
999  		    (req.ubi_num < 0 && req.ubi_num != UBI_DEV_NUM_AUTO)) {
1000  			err = -EINVAL;
1001  			break;
1002  		}
1003  
1004  		mtd = get_mtd_device(NULL, req.mtd_num);
1005  		if (IS_ERR(mtd)) {
1006  			err = PTR_ERR(mtd);
1007  			break;
1008  		}
1009  
1010  		/*
1011  		 * Note, further request verification is done by
1012  		 * 'ubi_attach_mtd_dev()'.
1013  		 */
1014  		mutex_lock(&ubi_devices_mutex);
1015  		err = ubi_attach_mtd_dev(mtd, req.ubi_num, req.vid_hdr_offset,
1016  					 req.max_beb_per1024);
1017  		mutex_unlock(&ubi_devices_mutex);
1018  		if (err < 0)
1019  			put_mtd_device(mtd);
1020  		else
1021  			/* @err contains UBI device number */
1022  			err = put_user(err, (__user int32_t *)argp);
1023  
1024  		break;
1025  	}
1026  
1027  	/* Detach an MTD device command */
1028  	case UBI_IOCDET:
1029  	{
1030  		int ubi_num;
1031  
1032  		dbg_gen("detach MTD device");
1033  		err = get_user(ubi_num, (__user int32_t *)argp);
1034  		if (err) {
1035  			err = -EFAULT;
1036  			break;
1037  		}
1038  
1039  		mutex_lock(&ubi_devices_mutex);
1040  		err = ubi_detach_mtd_dev(ubi_num, 0);
1041  		mutex_unlock(&ubi_devices_mutex);
1042  		break;
1043  	}
1044  
1045  	default:
1046  		err = -ENOTTY;
1047  		break;
1048  	}
1049  
1050  	return err;
1051  }
1052  
1053  #ifdef CONFIG_COMPAT
1054  static long vol_cdev_compat_ioctl(struct file *file, unsigned int cmd,
1055  				  unsigned long arg)
1056  {
1057  	unsigned long translated_arg = (unsigned long)compat_ptr(arg);
1058  
1059  	return vol_cdev_ioctl(file, cmd, translated_arg);
1060  }
1061  
1062  static long ubi_cdev_compat_ioctl(struct file *file, unsigned int cmd,
1063  				  unsigned long arg)
1064  {
1065  	unsigned long translated_arg = (unsigned long)compat_ptr(arg);
1066  
1067  	return ubi_cdev_ioctl(file, cmd, translated_arg);
1068  }
1069  
1070  static long ctrl_cdev_compat_ioctl(struct file *file, unsigned int cmd,
1071  				   unsigned long arg)
1072  {
1073  	unsigned long translated_arg = (unsigned long)compat_ptr(arg);
1074  
1075  	return ctrl_cdev_ioctl(file, cmd, translated_arg);
1076  }
1077  #else
1078  #define vol_cdev_compat_ioctl  NULL
1079  #define ubi_cdev_compat_ioctl  NULL
1080  #define ctrl_cdev_compat_ioctl NULL
1081  #endif
1082  
1083  /* UBI volume character device operations */
1084  const struct file_operations ubi_vol_cdev_operations = {
1085  	.owner          = THIS_MODULE,
1086  	.open           = vol_cdev_open,
1087  	.release        = vol_cdev_release,
1088  	.llseek         = vol_cdev_llseek,
1089  	.read           = vol_cdev_read,
1090  	.write          = vol_cdev_write,
1091  	.fsync		= vol_cdev_fsync,
1092  	.unlocked_ioctl = vol_cdev_ioctl,
1093  	.compat_ioctl   = vol_cdev_compat_ioctl,
1094  };
1095  
1096  /* UBI character device operations */
1097  const struct file_operations ubi_cdev_operations = {
1098  	.owner          = THIS_MODULE,
1099  	.llseek         = no_llseek,
1100  	.unlocked_ioctl = ubi_cdev_ioctl,
1101  	.compat_ioctl   = ubi_cdev_compat_ioctl,
1102  };
1103  
1104  /* UBI control character device operations */
1105  const struct file_operations ubi_ctrl_cdev_operations = {
1106  	.owner          = THIS_MODULE,
1107  	.unlocked_ioctl = ctrl_cdev_ioctl,
1108  	.compat_ioctl   = ctrl_cdev_compat_ioctl,
1109  	.llseek		= no_llseek,
1110  };
1111