libfstools: support file paths longer than 255 chars
[project/fstools.git] / libubi / libubi.c
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., 675 Mass Ave, Cambridge, MA 02139, USA.
17  *
18  * Author: Artem Bityutskiy
19  *
20  * UBI (Unsorted Block Images) library.
21  */
22
23 #define PROGRAM_NAME "libubi"
24
25 #include <sys/sysmacros.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <fcntl.h>
30 #include <dirent.h>
31 #include <unistd.h>
32 #include <limits.h>
33 #include <sys/ioctl.h>
34 #include <sys/stat.h>
35 #include <sys/types.h>
36 #include "libubi.h"
37 #include "libubi_int.h"
38
39 /**
40  * mkpath - compose full path from 2 given components.
41  * @path: the first component
42  * @name: the second component
43  *
44  * This function returns the resulting path in case of success and %NULL in
45  * case of failure.
46  */
47 static char *mkpath(const char *path, const char *name)
48 {
49         char *n;
50         int len1 = strlen(path);
51         int len2 = strlen(name);
52
53         n = malloc(len1 + len2 + 2);
54         if (!n) {
55                 sys_errmsg("cannot allocate %d bytes", len1 + len2 + 2);
56                 return NULL;
57         }
58
59         memcpy(n, path, len1);
60         if (n[len1 - 1] != '/')
61                 n[len1++] = '/';
62
63         memcpy(n + len1, name, len2 + 1);
64         return n;
65 }
66
67 /**
68  * read_positive_ll - read a positive 'long long' value from a file.
69  * @file: the file to read from
70  * @value: the result is stored here
71  *
72  * This function reads file @file and interprets its contents as a positive
73  * 'long long' integer. If this is not true, it fails with %EINVAL error code.
74  * Returns %0 in case of success and %-1 in case of failure.
75  */
76 static int read_positive_ll(const char *file, long long *value)
77 {
78         int fd, rd;
79         char buf[50];
80
81         fd = open(file, O_RDONLY);
82         if (fd == -1)
83                 return -1;
84
85         rd = read(fd, buf, sizeof(buf));
86         if (rd == -1) {
87                 sys_errmsg("cannot read \"%s\"", file);
88                 goto out_error;
89         }
90         if (rd == sizeof(buf)) {
91                 errmsg("contents of \"%s\" is too long", file);
92                 errno = EINVAL;
93                 goto out_error;
94         }
95         buf[rd] = '\0';
96
97         if (sscanf(buf, "%lld\n", value) != 1) {
98                 errmsg("cannot read integer from \"%s\"\n", file);
99                 errno = EINVAL;
100                 goto out_error;
101         }
102
103         if (*value < 0) {
104                 errmsg("negative value %lld in \"%s\"", *value, file);
105                 errno = EINVAL;
106                 goto out_error;
107         }
108
109         if (close(fd)) {
110                 sys_errmsg("close failed on \"%s\"", file);
111                 return -1;
112         }
113
114         return 0;
115
116 out_error:
117         close(fd);
118         return -1;
119 }
120
121 /**
122  * read_positive_int - read a positive 'int' value from a file.
123  * @file: the file to read from
124  * @value: the result is stored here
125  *
126  * This function is the same as 'read_positive_ll()', but it reads an 'int'
127  * value, not 'long long'.
128  */
129 static int read_positive_int(const char *file, int *value)
130 {
131         long long res;
132
133         if (read_positive_ll(file, &res))
134                 return -1;
135
136         /* Make sure the value is not too big */
137         if (res > INT_MAX) {
138                 errmsg("value %lld read from file \"%s\" is out of range",
139                        res, file);
140                 errno = EINVAL;
141                 return -1;
142         }
143
144         *value = res;
145         return 0;
146 }
147
148 /**
149  * read_data - read data from a file.
150  * @file: the file to read from
151  * @buf: the buffer to read to
152  * @buf_len: buffer length
153  *
154  * This function returns number of read bytes in case of success and %-1 in
155  * case of failure. Note, if the file contains more then @buf_len bytes of
156  * date, this function fails with %EINVAL error code.
157  */
158 static int read_data(const char *file, void *buf, int buf_len)
159 {
160         int fd, rd, tmp, tmp1;
161
162         fd = open(file, O_RDONLY);
163         if (fd == -1)
164                 return -1;
165
166         rd = read(fd, buf, buf_len);
167         if (rd == -1) {
168                 sys_errmsg("cannot read \"%s\"", file);
169                 goto out_error;
170         }
171
172         if (rd == buf_len) {
173                 errmsg("contents of \"%s\" is too long", file);
174                 errno = EINVAL;
175                 goto out_error;
176         }
177
178         ((char *)buf)[rd] = '\0';
179
180         /* Make sure all data is read */
181         tmp1 = read(fd, &tmp, 1);
182         if (tmp1 == 1) {
183                 sys_errmsg("cannot read \"%s\"", file);
184                 goto out_error;
185         }
186         if (tmp1) {
187                 errmsg("file \"%s\" contains too much data (> %d bytes)",
188                        file, buf_len);
189                 errno = EINVAL;
190                 goto out_error;
191         }
192
193         if (close(fd)) {
194                 sys_errmsg("close failed on \"%s\"", file);
195                 return -1;
196         }
197
198         return rd;
199
200 out_error:
201         close(fd);
202         return -1;
203 }
204
205 /**
206  * read_major - read major and minor numbers from a file.
207  * @file: name of the file to read from
208  * @major: major number is returned here
209  * @minor: minor number is returned here
210  *
211  * This function returns % in case of succes, and %-1 in case of failure.
212  */
213 static int read_major(const char *file, int *major, int *minor)
214 {
215         int ret;
216         char buf[50];
217
218         ret = read_data(file, buf, 50);
219         if (ret < 0)
220                 return ret;
221
222         ret = sscanf(buf, "%d:%d\n", major, minor);
223         if (ret != 2) {
224                 errno = EINVAL;
225                 errmsg("\"%s\" does not have major:minor format", file);
226                 return -1;
227         }
228
229         if (*major < 0 || *minor < 0) {
230                 errno = EINVAL;
231                 errmsg("bad major:minor %d:%d in \"%s\"",
232                               *major, *minor, file);
233                 return -1;
234         }
235
236         return 0;
237 }
238
239 /**
240  * dev_read_int - read a positive 'int' value from an UBI device sysfs file.
241  * @patt: file pattern to read from
242  * @dev_num: UBI device number
243  * @value: the result is stored here
244  *
245  * This function returns %0 in case of success and %-1 in case of failure.
246  */
247 static int dev_read_int(const char *patt, int dev_num, int *value)
248 {
249         char file[strlen(patt) + 50];
250
251         sprintf(file, patt, dev_num);
252         return read_positive_int(file, value);
253 }
254
255 /**
256  * vol_read_int - read a positive 'int' value from an UBI volume sysfs file.
257  * @patt: file pattern to read from
258  * @dev_num: UBI device number
259  * @vol_id: volume ID
260  * @value: the result is stored here
261  *
262  * This function returns %0 in case of success and %-1 in case of failure.
263  */
264 static int vol_read_int(const char *patt, int dev_num, int vol_id, int *value)
265 {
266         char file[strlen(patt) + 100];
267
268         sprintf(file, patt, dev_num, vol_id);
269         return read_positive_int(file, value);
270 }
271
272 /**
273  * dev_read_ll - read a positive 'long long' value from an UBI device sysfs file.
274  * @patt: file pattern to read from
275  * @dev_num: UBI device number
276  * @value: the result is stored here
277  *
278  * This function returns %0 in case of success and %-1 in case of failure.
279  */
280 static int dev_read_ll(const char *patt, int dev_num, long long *value)
281 {
282         char file[strlen(patt) + 50];
283
284         sprintf(file, patt, dev_num);
285         return read_positive_ll(file, value);
286 }
287
288 /**
289  * vol_read_ll - read a positive 'long long' value from an UBI volume sysfs file.
290  * @patt: file pattern to read from
291  * @dev_num: UBI device number
292  * @vol_id: volume ID
293  * @value: the result is stored here
294  *
295  * This function returns %0 in case of success and %-1 in case of failure.
296  */
297 static int vol_read_ll(const char *patt, int dev_num, int vol_id,
298                        long long *value)
299 {
300         char file[strlen(patt) + 100];
301
302         sprintf(file, patt, dev_num, vol_id);
303         return read_positive_ll(file, value);
304 }
305
306 /**
307  * vol_read_data - read data from an UBI volume's sysfs file.
308  * @patt: file pattern to read from
309  * @dev_num: UBI device number
310  * @vol_id: volume ID
311  * @buf: buffer to read to
312  * @buf_len: buffer length
313  *
314  * This function returns number of read bytes in case of success and %-1 in
315  * case of failure.
316  */
317 static int vol_read_data(const char *patt, int dev_num, int vol_id, void *buf,
318                          int buf_len)
319 {
320         char file[strlen(patt) + 100];
321
322         sprintf(file, patt, dev_num, vol_id);
323         return read_data(file, buf, buf_len);
324 }
325
326 /**
327  * dev_get_major - get major and minor numbers of an UBI device.
328  * @lib: libubi descriptor
329  * @dev_num: UBI device number
330  * @major: major number is returned here
331  * @minor: minor number is returned here
332  *
333  * This function returns zero in case of succes and %-1 in case of failure.
334  */
335 static int dev_get_major(struct libubi *lib, int dev_num, int *major, int *minor)
336 {
337         char file[strlen(lib->dev_dev) + 50];
338
339         sprintf(file, lib->dev_dev, dev_num);
340         return read_major(file, major, minor);
341 }
342
343 /**
344  * vol_get_major - get major and minor numbers of an UBI volume.
345  * @lib: libubi descriptor
346  * @dev_num: UBI device number
347  * @vol_id: volume ID
348  * @major: major number is returned here
349  * @minor: minor number is returned here
350  *
351  * This function returns zero in case of succes and %-1 in case of failure.
352  */
353 static int vol_get_major(struct libubi *lib, int dev_num, int vol_id,
354                          int *major, int *minor)
355 {
356         char file[strlen(lib->vol_dev) + 100];
357
358         sprintf(file, lib->vol_dev, dev_num, vol_id);
359         return read_major(file, major, minor);
360 }
361
362 /**
363  * vol_node2nums - find UBI device number and volume ID by volume device node
364  *                 file.
365  * @lib: UBI library descriptor
366  * @node: UBI character device node name
367  * @dev_num: UBI device number is returned here
368  * @vol_id: volume ID is returned hers
369  *
370  * This function returns zero in case of succes and %-1 in case of failure.
371  */
372 static int vol_node2nums(struct libubi *lib, const char *node, int *dev_num,
373                          int *vol_id)
374 {
375         struct stat st;
376         struct ubi_info info;
377         int i, fd, major, minor;
378         char file[strlen(lib->ubi_vol) + 100];
379
380         if (stat(node, &st)) {
381                 sys_errmsg("cannot get information about \"%s\"",
382                                   node);
383                 return -1;
384         }
385         if (!S_ISCHR(st.st_mode)) {
386                 errno = EINVAL;
387                 errmsg("\"%s\" is not a character device", node);
388                 return -1;
389         }
390
391         major = major(st.st_rdev);
392         minor = minor(st.st_rdev);
393
394         if (minor == 0) {
395                 errno = EINVAL;
396                 errmsg("\"%s\" is not a volume character device", node);
397                 return -1;
398         }
399
400         if (ubi_get_info((libubi_t *)lib, &info))
401                 return -1;
402
403         for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
404                 int major1, minor1, ret;
405
406                 ret = dev_get_major(lib, i, &major1, &minor1);
407                 if (ret) {
408                         if (errno == ENOENT)
409                                 continue;
410                         return -1;
411                 }
412
413                 if (major1 == major)
414                         break;
415         }
416
417         if (i > info.highest_dev_num) {
418                 errno = ENODEV;
419                 return -1;
420         }
421
422         /* Make sure this UBI volume exists */
423         sprintf(file, lib->ubi_vol, i, minor - 1);
424         fd = open(file, O_RDONLY);
425         if (fd == -1) {
426                 errno = ENODEV;
427                 return -1;
428         }
429
430         *dev_num = i;
431         *vol_id = minor - 1;
432         errno = 0;
433         return 0;
434 }
435
436 /**
437  * dev_node2num - find UBI device number by its character device node.
438  * @lib: UBI library descriptor
439  * @node: UBI character device node name
440  * @dev_num: UBI device number is returned here
441  *
442  * This function returns %0 in case of success and %-1 in case of failure.
443  */
444 static int dev_node2num(struct libubi *lib, const char *node, int *dev_num)
445 {
446         struct stat st;
447         struct ubi_info info;
448         int i, major, minor;
449
450         if (stat(node, &st)) {
451                 sys_errmsg("cannot get information about \"%s\"", node);
452                 return -1;
453         }
454         if (!S_ISCHR(st.st_mode)) {
455                 errno = EINVAL;
456                 errmsg("\"%s\" is not a character device", node);
457                 return -1;
458         }
459
460         major = major(st.st_rdev);
461         minor = minor(st.st_rdev);
462
463         if (minor != 0) {
464                 errno = EINVAL;
465                 errmsg("\"%s\" is not an UBI character device", node);
466                 return -1;
467         }
468
469         if (ubi_get_info((libubi_t *)lib, &info))
470                 return -1;
471
472         for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
473                 int major1, minor1, ret;
474
475                 ret = dev_get_major(lib, i, &major1, &minor1);
476                 if (ret) {
477                         if (errno == ENOENT)
478                                 continue;
479                         return -1;
480                 }
481
482                 if (major1 == major) {
483                         if (minor1 != 0) {
484                                 errmsg("UBI character device minor number is "
485                                        "%d, but must be 0", minor1);
486                                 errno = EINVAL;
487                                 return -1;
488                         }
489                         errno = 0;
490                         *dev_num = i;
491                         return 0;
492                 }
493         }
494
495         errno = ENODEV;
496         return -1;
497 }
498
499 int mtd_num2ubi_dev(libubi_t desc, int mtd_num, int *dev_num)
500 {
501         struct ubi_info info;
502         int i, ret, mtd_num1;
503         struct libubi *lib = desc;
504
505         if (ubi_get_info(desc, &info))
506                 return -1;
507
508         for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
509                 ret = dev_read_int(lib->dev_mtd_num, i, &mtd_num1);
510                 if (ret) {
511                         if (errno == ENOENT)
512                                 continue;
513                         return -1;
514                 }
515
516                 if (mtd_num1 == mtd_num) {
517                         errno = 0;
518                         *dev_num = i;
519                         return 0;
520                 }
521         }
522
523         errno = 0;
524         return -1;
525 }
526
527 libubi_t libubi_open(void)
528 {
529         int fd, version;
530         struct libubi *lib;
531
532         lib = calloc(1, sizeof(struct libubi));
533         if (!lib)
534                 return NULL;
535
536         lib->sysfs_ctrl = mkpath("/sys", SYSFS_CTRL);
537         if (!lib->sysfs_ctrl)
538                 goto out_error;
539
540         lib->ctrl_dev = mkpath(lib->sysfs_ctrl, CTRL_DEV);
541         if (!lib->ctrl_dev)
542                 goto out_error;
543
544         lib->sysfs_ubi = mkpath("/sys", SYSFS_UBI);
545         if (!lib->sysfs_ubi)
546                 goto out_error;
547
548         /* Make sure UBI is present */
549         fd = open(lib->sysfs_ubi, O_RDONLY);
550         if (fd == -1) {
551                 errno = 0;
552                 goto out_error;
553         }
554
555         if (close(fd)) {
556                 sys_errmsg("close failed on \"%s\"", lib->sysfs_ubi);
557                 goto out_error;
558         }
559
560         lib->ubi_dev = mkpath(lib->sysfs_ubi, UBI_DEV_NAME_PATT);
561         if (!lib->ubi_dev)
562                 goto out_error;
563
564         lib->ubi_version = mkpath(lib->sysfs_ubi, UBI_VER);
565         if (!lib->ubi_version)
566                 goto out_error;
567
568         lib->dev_dev = mkpath(lib->ubi_dev, DEV_DEV);
569         if (!lib->dev_dev)
570                 goto out_error;
571
572         lib->dev_avail_ebs = mkpath(lib->ubi_dev, DEV_AVAIL_EBS);
573         if (!lib->dev_avail_ebs)
574                 goto out_error;
575
576         lib->dev_total_ebs = mkpath(lib->ubi_dev, DEV_TOTAL_EBS);
577         if (!lib->dev_total_ebs)
578                 goto out_error;
579
580         lib->dev_bad_count = mkpath(lib->ubi_dev, DEV_BAD_COUNT);
581         if (!lib->dev_bad_count)
582                 goto out_error;
583
584         lib->dev_eb_size = mkpath(lib->ubi_dev, DEV_EB_SIZE);
585         if (!lib->dev_eb_size)
586                 goto out_error;
587
588         lib->dev_max_ec = mkpath(lib->ubi_dev, DEV_MAX_EC);
589         if (!lib->dev_max_ec)
590                 goto out_error;
591
592         lib->dev_bad_rsvd = mkpath(lib->ubi_dev, DEV_MAX_RSVD);
593         if (!lib->dev_bad_rsvd)
594                 goto out_error;
595
596         lib->dev_max_vols = mkpath(lib->ubi_dev, DEV_MAX_VOLS);
597         if (!lib->dev_max_vols)
598                 goto out_error;
599
600         lib->dev_min_io_size = mkpath(lib->ubi_dev, DEV_MIN_IO_SIZE);
601         if (!lib->dev_min_io_size)
602                 goto out_error;
603
604         lib->dev_mtd_num = mkpath(lib->ubi_dev, DEV_MTD_NUM);
605         if (!lib->dev_mtd_num)
606                 goto out_error;
607
608         lib->ubi_vol = mkpath(lib->sysfs_ubi, UBI_VOL_NAME_PATT);
609         if (!lib->ubi_vol)
610                 goto out_error;
611
612         lib->vol_type = mkpath(lib->ubi_vol, VOL_TYPE);
613         if (!lib->vol_type)
614                 goto out_error;
615
616         lib->vol_dev = mkpath(lib->ubi_vol, VOL_DEV);
617         if (!lib->vol_dev)
618                 goto out_error;
619
620         lib->vol_alignment = mkpath(lib->ubi_vol, VOL_ALIGNMENT);
621         if (!lib->vol_alignment)
622                 goto out_error;
623
624         lib->vol_data_bytes = mkpath(lib->ubi_vol, VOL_DATA_BYTES);
625         if (!lib->vol_data_bytes)
626                 goto out_error;
627
628         lib->vol_rsvd_ebs = mkpath(lib->ubi_vol, VOL_RSVD_EBS);
629         if (!lib->vol_rsvd_ebs)
630                 goto out_error;
631
632         lib->vol_eb_size = mkpath(lib->ubi_vol, VOL_EB_SIZE);
633         if (!lib->vol_eb_size)
634                 goto out_error;
635
636         lib->vol_corrupted = mkpath(lib->ubi_vol, VOL_CORRUPTED);
637         if (!lib->vol_corrupted)
638                 goto out_error;
639
640         lib->vol_name = mkpath(lib->ubi_vol, VOL_NAME);
641         if (!lib->vol_name)
642                 goto out_error;
643
644         if (read_positive_int(lib->ubi_version, &version))
645                 goto out_error;
646         if (version != LIBUBI_UBI_VERSION) {
647                 errmsg("this library was made for UBI version %d, but UBI "
648                        "version %d is detected\n", LIBUBI_UBI_VERSION, version);
649                 goto out_error;
650         }
651
652         return lib;
653
654 out_error:
655         libubi_close((libubi_t)lib);
656         return NULL;
657 }
658
659 void libubi_close(libubi_t desc)
660 {
661         struct libubi *lib = (struct libubi *)desc;
662
663         free(lib->vol_name);
664         free(lib->vol_corrupted);
665         free(lib->vol_eb_size);
666         free(lib->vol_rsvd_ebs);
667         free(lib->vol_data_bytes);
668         free(lib->vol_alignment);
669         free(lib->vol_dev);
670         free(lib->vol_type);
671         free(lib->ubi_vol);
672         free(lib->dev_mtd_num);
673         free(lib->dev_min_io_size);
674         free(lib->dev_max_vols);
675         free(lib->dev_bad_rsvd);
676         free(lib->dev_max_ec);
677         free(lib->dev_eb_size);
678         free(lib->dev_bad_count);
679         free(lib->dev_total_ebs);
680         free(lib->dev_avail_ebs);
681         free(lib->dev_dev);
682         free(lib->ubi_version);
683         free(lib->ubi_dev);
684         free(lib->sysfs_ubi);
685         free(lib->ctrl_dev);
686         free(lib->sysfs_ctrl);
687         free(lib);
688 }
689
690 /**
691  * do_attach - perform the actual attach operation.
692  * @node: name of the UBI control character device node
693  * @r: attach request
694  *
695  * This function performs the actual UBI attach operation. Returns %0 in case of
696  * success and %-1 in case of failure. @r->ubi_num contains newly created UBI
697  * device number.
698  */
699 static int do_attach(const char *node, const struct ubi_attach_req *r)
700 {
701         int fd, ret;
702
703         fd = open(node, O_RDONLY);
704         if (fd == -1) {
705                 sys_errmsg("cannot open \"%s\"", node);
706                 return -1;
707         }
708         ret = ioctl(fd, UBI_IOCATT, r);
709         close(fd);
710         if (ret == -1)
711                 return -1;
712
713 #ifdef UDEV_SETTLE_HACK
714 //      if (system("udevsettle") == -1)
715 //              return -1;
716         usleep(100000);
717 #endif
718         return ret;
719 }
720
721 #ifndef MTD_CHAR_MAJOR
722 /*
723  * This is taken from kernel <linux/mtd/mtd.h> and is unlikely to change anytime
724  * soon.
725  */
726 #define MTD_CHAR_MAJOR 90
727 #endif
728
729 /**
730  * mtd_node_to_num - converts device node to MTD number.
731  * @mtd_dev_node: path to device node to convert
732  *
733  * This function converts given @mtd_dev_node to MTD device number.
734  * @mtd_dev_node should contain path to the MTD device node. Returns MTD device
735  * number in case of success and %-1 in case of failure (errno is set).
736  */
737 static int mtd_node_to_num(const char *mtd_dev_node)
738 {
739         int major, minor;
740         struct stat sb;
741
742         if (stat(mtd_dev_node, &sb) < 0) {
743                 sys_errmsg("cannot stat \"%s\"", mtd_dev_node);
744                 return -1;
745         }
746
747         if (!S_ISCHR(sb.st_mode)) {
748                 errno = EINVAL;
749                 sys_errmsg("\"%s\" is not a character device",
750                                   mtd_dev_node);
751                 return -1;
752         }
753
754         major = major(sb.st_rdev);
755         minor = minor(sb.st_rdev);
756
757         if (major != MTD_CHAR_MAJOR) {
758                 errno = EINVAL;
759                 sys_errmsg("\"%s\" is not an MTD device", mtd_dev_node);
760                 return -1;
761         }
762
763         return minor / 2;
764 }
765
766 int ubi_attach(libubi_t desc, const char *node, struct ubi_attach_request *req)
767 {
768         struct ubi_attach_req r;
769         int ret;
770
771         (void)desc;
772
773         if (req->mtd_dev_node) {
774                 /*
775                  * User has passed path to device node. Lets find out MTD
776                  * device number of the device and update req->mtd_num with it
777                  */
778                 req->mtd_num = mtd_node_to_num(req->mtd_dev_node);
779                 if (req->mtd_num == -1)
780                         return -1;
781         }
782
783         memset(&r, 0, sizeof(struct ubi_attach_req));
784         r.ubi_num = req->dev_num;
785         r.mtd_num = req->mtd_num;
786         r.vid_hdr_offset = req->vid_hdr_offset;
787
788         if (req->max_beb_per1024) {
789                 /*
790                  * We first have to check if the running kernel supports the
791                  * 'max_beb_per1024' parameter. To do this, we invoke the
792                  * "attach" ioctl 2 times: first with incorrect value %-1 of
793                  * 'max_beb_per1024'.
794                  *
795                  * If the ioctl succeeds, it means that the kernel doesn't
796                  * support the feature and just ignored our 'max_beb_per1024'
797                  * value.
798                  *
799                  * If the ioctl returns -EINVAL, we assume this is because
800                  * 'max_beb_per1024' was set to -1, and we invoke the ioctl for
801                  * the second time with the 'max_beb_per1024' value.
802                  */
803                 r.max_beb_per1024 = -1;
804                 ret = do_attach(node, &r);
805                 if (ret == 0) {
806                         req->dev_num = r.ubi_num;
807                         /*
808                          * The call succeeded. It means that the kernel ignored
809                          * 'max_beb_per1024' parameter. 
810                          */
811                         return 1;
812                 } else if (errno != EINVAL)
813                         return ret;
814         }
815
816         r.max_beb_per1024 = req->max_beb_per1024;
817
818         ret = do_attach(node, &r);
819         if (ret == 0)
820                 req->dev_num = r.ubi_num;
821
822         return ret;
823 }
824
825 int ubi_detach_mtd(libubi_t desc, const char *node, int mtd_num)
826 {
827         int ret, ubi_dev;
828
829         ret = mtd_num2ubi_dev(desc, mtd_num, &ubi_dev);
830         if (ret == -1) {
831                 errno = ENODEV;
832                 return ret;
833         }
834
835         return ubi_remove_dev(desc, node, ubi_dev);
836 }
837
838 int ubi_detach(libubi_t desc, const char *node, const char *mtd_dev_node)
839 {
840         int mtd_num;
841
842         if (!mtd_dev_node) {
843                 errno = EINVAL;
844                 return -1;
845         }
846
847         mtd_num = mtd_node_to_num(mtd_dev_node);
848         if (mtd_num == -1)
849                 return -1;
850
851         return ubi_detach_mtd(desc, node, mtd_num);
852 }
853
854 int ubi_remove_dev(libubi_t desc, const char *node, int ubi_dev)
855 {
856         int fd, ret;
857
858         desc = desc;
859
860         fd = open(node, O_RDONLY);
861         if (fd == -1) {
862                 sys_errmsg("cannot open \"%s\"", node);
863                 return -1;
864         }
865         ret = ioctl(fd, UBI_IOCFDET, &ubi_dev);
866         if (ret == -1)
867                 goto out_close;
868
869 #ifdef UDEV_SETTLE_HACK
870 //      if (system("udevsettle") == -1)
871 //              return -1;
872         usleep(100000);
873 #endif
874
875 out_close:
876         close(fd);
877         return ret;
878 }
879
880 int ubi_probe_node(libubi_t desc, const char *node)
881 {
882         struct stat st;
883         struct ubi_info info;
884         int i, fd, major, minor;
885         struct libubi *lib = (struct libubi *)desc;
886         char file[strlen(lib->ubi_vol) + 100];
887
888         if (stat(node, &st)) {
889                 sys_errmsg("cannot get information about \"%s\"", node);
890                 return -1;
891         }
892
893         if (!S_ISCHR(st.st_mode)) {
894                 errmsg("\"%s\" is not a character device", node);
895                 errno = EINVAL;
896                 return -1;
897         }
898
899         major = major(st.st_rdev);
900         minor = minor(st.st_rdev);
901
902         if (ubi_get_info((libubi_t *)lib, &info))
903                 return -1;
904
905         for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
906                 int major1, minor1, ret;
907
908                 ret = dev_get_major(lib, i, &major1, &minor1);
909                 if (ret) {
910                         if (errno == ENOENT)
911                                 continue;
912                         if (!errno)
913                                 goto out_not_ubi;
914                         return -1;
915                 }
916
917                 if (major1 == major)
918                         break;
919         }
920
921         if (i > info.highest_dev_num)
922                 goto out_not_ubi;
923
924         if (minor == 0)
925                 return 1;
926
927         /* This is supposdely an UBI volume device node */
928         sprintf(file, lib->ubi_vol, i, minor - 1);
929         fd = open(file, O_RDONLY);
930         if (fd == -1)
931                 goto out_not_ubi;
932
933         return 2;
934
935 out_not_ubi:
936         errmsg("\"%s\" has major:minor %d:%d, but this does not correspond to "
937                "any existing UBI device or volume", node, major, minor);
938         errno = ENODEV;
939         return -1;
940 }
941
942 int ubi_get_info(libubi_t desc, struct ubi_info *info)
943 {
944         DIR *sysfs_ubi;
945         struct dirent *dirent;
946         struct libubi *lib = (struct libubi *)desc;
947
948         memset(info, 0, sizeof(struct ubi_info));
949
950         if (read_major(lib->ctrl_dev, &info->ctrl_major, &info->ctrl_minor)) {
951                 /*
952                  * Older UBI versions did not have control device, so we do not
953                  * panic here for compatibility reasons. May be few years later
954                  * we could return -1 here, but for now just set major:minor to
955                  * -1.
956                  */
957                 info->ctrl_major = info->ctrl_minor = -1;
958         }
959
960         /*
961          * We have to scan the UBI sysfs directory to identify how many UBI
962          * devices are present.
963          */
964         sysfs_ubi = opendir(lib->sysfs_ubi);
965         if (!sysfs_ubi)
966                 return -1;
967
968         info->lowest_dev_num = INT_MAX;
969         while (1) {
970                 int dev_num, ret;
971                 char tmp_buf[256];
972
973                 errno = 0;
974                 dirent = readdir(sysfs_ubi);
975                 if (!dirent)
976                         break;
977
978                 if (strlen(dirent->d_name) >= 255) {
979                         errmsg("invalid entry in %s: \"%s\"",
980                                lib->sysfs_ubi, dirent->d_name);
981                         errno = EINVAL;
982                         goto out_close;
983                 }
984
985                 ret = sscanf(dirent->d_name, UBI_DEV_NAME_PATT"%s",
986                              &dev_num, tmp_buf);
987                 if (ret == 1) {
988                         info->dev_count += 1;
989                         if (dev_num > info->highest_dev_num)
990                                 info->highest_dev_num = dev_num;
991                         if (dev_num < info->lowest_dev_num)
992                                 info->lowest_dev_num = dev_num;
993                 }
994         }
995
996         if (!dirent && errno) {
997                 sys_errmsg("readdir failed on \"%s\"", lib->sysfs_ubi);
998                 goto out_close;
999         }
1000
1001         if (closedir(sysfs_ubi)) {
1002                 sys_errmsg("closedir failed on \"%s\"", lib->sysfs_ubi);
1003                 return -1;
1004         }
1005         if (info->lowest_dev_num == INT_MAX)
1006                 info->lowest_dev_num = 0;
1007
1008         if (read_positive_int(lib->ubi_version, &info->version))
1009                 return -1;
1010
1011         return 0;
1012
1013 out_close:
1014         closedir(sysfs_ubi);
1015         return -1;
1016 }
1017
1018 int ubi_mkvol(libubi_t desc, const char *node, struct ubi_mkvol_request *req)
1019 {
1020         int fd, ret;
1021         struct ubi_mkvol_req r;
1022         size_t n;
1023
1024         memset(&r, 0, sizeof(struct ubi_mkvol_req));
1025
1026         desc = desc;
1027         r.vol_id = req->vol_id;
1028         r.alignment = req->alignment;
1029         r.bytes = req->bytes;
1030         r.vol_type = req->vol_type;
1031
1032         n = strlen(req->name);
1033         if (n > UBI_MAX_VOLUME_NAME)
1034                 return -1;
1035
1036         strncpy(r.name, req->name, UBI_MAX_VOLUME_NAME + 1);
1037         r.name_len = n;
1038
1039         desc = desc;
1040         fd = open(node, O_RDONLY);
1041         if (fd == -1) {
1042                 sys_errmsg("cannot open \"%s\"", node);
1043                 return -1;
1044         }
1045         ret = ioctl(fd, UBI_IOCMKVOL, &r);
1046         if (ret == -1) {
1047                 close(fd);
1048                 return ret;
1049         }
1050
1051         close(fd);
1052         req->vol_id = r.vol_id;
1053
1054 #ifdef UDEV_SETTLE_HACK
1055 //      if (system("udevsettle") == -1)
1056 //              return -1;
1057         usleep(100000);
1058 #endif
1059
1060         return 0;
1061 }
1062
1063 int ubi_rmvol(libubi_t desc, const char *node, int vol_id)
1064 {
1065         int fd, ret;
1066
1067         desc = desc;
1068         fd = open(node, O_RDONLY);
1069         if (fd == -1) {
1070                 sys_errmsg("cannot open \"%s\"", node);
1071                 return -1;
1072         }
1073
1074         ret = ioctl(fd, UBI_IOCRMVOL, &vol_id);
1075         if (ret == -1) {
1076                 close(fd);
1077                 return ret;
1078         }
1079
1080         close(fd);
1081
1082 #ifdef UDEV_SETTLE_HACK
1083 //      if (system("udevsettle") == -1)
1084 //              return -1;
1085         usleep(100000);
1086 #endif
1087
1088         return 0;
1089 }
1090
1091 int ubi_rnvols(libubi_t desc, const char *node, struct ubi_rnvol_req *rnvol)
1092 {
1093         int fd, ret;
1094
1095         desc = desc;
1096         fd = open(node, O_RDONLY);
1097         if (fd == -1)
1098                 return -1;
1099
1100         ret = ioctl(fd, UBI_IOCRNVOL, rnvol);
1101         if (ret == -1) {
1102                 close(fd);
1103                 return ret;
1104         }
1105
1106         close(fd);
1107
1108 #ifdef UDEV_SETTLE_HACK
1109 //      if (system("udevsettle") == -1)
1110 //              return -1;
1111         usleep(100000);
1112 #endif
1113
1114         return 0;
1115 }
1116
1117 int ubi_rsvol(libubi_t desc, const char *node, int vol_id, long long bytes)
1118 {
1119         int fd, ret;
1120         struct ubi_rsvol_req req;
1121
1122         desc = desc;
1123         fd = open(node, O_RDONLY);
1124         if (fd == -1) {
1125                 sys_errmsg("cannot open \"%s\"", node);
1126                 return -1;
1127         }
1128         req.bytes = bytes;
1129         req.vol_id = vol_id;
1130
1131         ret = ioctl(fd, UBI_IOCRSVOL, &req);
1132         close(fd);
1133         return ret;
1134 }
1135
1136 int ubi_update_start(libubi_t desc, int fd, long long bytes)
1137 {
1138         desc = desc;
1139         if (ioctl(fd, UBI_IOCVOLUP, &bytes))
1140                 return -1;
1141         return 0;
1142 }
1143
1144 int ubi_leb_change_start(libubi_t desc, int fd, int lnum, int bytes)
1145 {
1146         struct ubi_leb_change_req req;
1147
1148         desc = desc;
1149         memset(&req, 0, sizeof(struct ubi_leb_change_req));
1150         req.lnum = lnum;
1151         req.bytes = bytes;
1152         req.dtype = 3;
1153
1154         if (ioctl(fd, UBI_IOCEBCH, &req))
1155                 return -1;
1156         return 0;
1157 }
1158
1159 int ubi_dev_present(libubi_t desc, int dev_num)
1160 {
1161         struct stat st;
1162         struct libubi *lib = (struct libubi *)desc;
1163         char file[strlen(lib->ubi_dev) + 50];
1164
1165         sprintf(file, lib->ubi_dev, dev_num);
1166         return !stat(file, &st);
1167 }
1168
1169 int ubi_get_dev_info1(libubi_t desc, int dev_num, struct ubi_dev_info *info)
1170 {
1171         DIR *sysfs_ubi;
1172         struct dirent *dirent;
1173         struct libubi *lib = (struct libubi *)desc;
1174
1175         memset(info, 0, sizeof(struct ubi_dev_info));
1176         info->dev_num = dev_num;
1177
1178         if (!ubi_dev_present(desc, dev_num))
1179                 return -1;
1180
1181         sysfs_ubi = opendir(lib->sysfs_ubi);
1182         if (!sysfs_ubi)
1183                 return -1;
1184
1185         info->lowest_vol_id = INT_MAX;
1186
1187         while (1) {
1188                 int vol_id, ret, devno;
1189                 char tmp_buf[256];
1190
1191                 errno = 0;
1192                 dirent = readdir(sysfs_ubi);
1193                 if (!dirent)
1194                         break;
1195
1196                 if (strlen(dirent->d_name) >= 255) {
1197                         errmsg("invalid entry in %s: \"%s\"",
1198                                lib->sysfs_ubi, dirent->d_name);
1199                         goto out_close;
1200                 }
1201
1202                 ret = sscanf(dirent->d_name, UBI_VOL_NAME_PATT"%s", &devno, &vol_id, tmp_buf);
1203                 if (ret == 2 && devno == dev_num) {
1204                         info->vol_count += 1;
1205                         if (vol_id > info->highest_vol_id)
1206                                 info->highest_vol_id = vol_id;
1207                         if (vol_id < info->lowest_vol_id)
1208                                 info->lowest_vol_id = vol_id;
1209                 }
1210         }
1211
1212         if (!dirent && errno) {
1213                 sys_errmsg("readdir failed on \"%s\"", lib->sysfs_ubi);
1214                 goto out_close;
1215         }
1216
1217         if (closedir(sysfs_ubi)) {
1218                 sys_errmsg("closedir failed on \"%s\"", lib->sysfs_ubi);
1219                 return -1;
1220         }
1221         if (info->lowest_vol_id == INT_MAX)
1222                 info->lowest_vol_id = 0;
1223
1224         if (dev_get_major(lib, dev_num, &info->major, &info->minor))
1225                 return -1;
1226
1227         if (dev_read_int(lib->dev_mtd_num, dev_num, &info->mtd_num))
1228                 return -1;
1229         if (dev_read_int(lib->dev_avail_ebs, dev_num, &info->avail_lebs))
1230                 return -1;
1231         if (dev_read_int(lib->dev_total_ebs, dev_num, &info->total_lebs))
1232                 return -1;
1233         if (dev_read_int(lib->dev_bad_count, dev_num, &info->bad_count))
1234                 return -1;
1235         if (dev_read_int(lib->dev_eb_size, dev_num, &info->leb_size))
1236                 return -1;
1237         if (dev_read_int(lib->dev_bad_rsvd, dev_num, &info->bad_rsvd))
1238                 return -1;
1239         if (dev_read_ll(lib->dev_max_ec, dev_num, &info->max_ec))
1240                 return -1;
1241         if (dev_read_int(lib->dev_max_vols, dev_num, &info->max_vol_count))
1242                 return -1;
1243         if (dev_read_int(lib->dev_min_io_size, dev_num, &info->min_io_size))
1244                 return -1;
1245
1246         info->avail_bytes = (long long)info->avail_lebs * info->leb_size;
1247         info->total_bytes = (long long)info->total_lebs * info->leb_size;
1248
1249         return 0;
1250
1251 out_close:
1252         closedir(sysfs_ubi);
1253         return -1;
1254 }
1255
1256 int ubi_get_dev_info(libubi_t desc, const char *node, struct ubi_dev_info *info)
1257 {
1258         int err, dev_num = 0;
1259         struct libubi *lib = (struct libubi *)desc;
1260
1261         err = ubi_probe_node(desc, node);
1262         if (err != 1) {
1263                 if (err == 2)
1264                         errno = ENODEV;
1265                 return -1;
1266         }
1267
1268         if (dev_node2num(lib, node, &dev_num))
1269                 return -1;
1270
1271         return ubi_get_dev_info1(desc, dev_num, info);
1272 }
1273
1274 int ubi_get_vol_info1(libubi_t desc, int dev_num, int vol_id,
1275                       struct ubi_vol_info *info)
1276 {
1277         int ret;
1278         struct libubi *lib = (struct libubi *)desc;
1279         char buf[50];
1280
1281         memset(info, 0, sizeof(struct ubi_vol_info));
1282         info->dev_num = dev_num;
1283         info->vol_id = vol_id;
1284
1285         if (vol_get_major(lib, dev_num, vol_id, &info->major, &info->minor))
1286                 return -1;
1287
1288         ret = vol_read_data(lib->vol_type, dev_num, vol_id, buf, 50);
1289         if (ret < 0)
1290                 return -1;
1291
1292         if (strncmp(buf, "static\n", ret) == 0)
1293                 info->type = UBI_STATIC_VOLUME;
1294         else if (strncmp(buf, "dynamic\n", ret) == 0)
1295                 info->type = UBI_DYNAMIC_VOLUME;
1296         else {
1297                 errmsg("bad value at \"%s\"", buf);
1298                 errno = EINVAL;
1299                 return -1;
1300         }
1301
1302         ret = vol_read_int(lib->vol_alignment, dev_num, vol_id,
1303                            &info->alignment);
1304         if (ret)
1305                 return -1;
1306         ret = vol_read_ll(lib->vol_data_bytes, dev_num, vol_id,
1307                           &info->data_bytes);
1308         if (ret)
1309                 return -1;
1310         ret = vol_read_int(lib->vol_rsvd_ebs, dev_num, vol_id, &info->rsvd_lebs);
1311         if (ret)
1312                 return -1;
1313         ret = vol_read_int(lib->vol_eb_size, dev_num, vol_id, &info->leb_size);
1314         if (ret)
1315                 return -1;
1316         ret = vol_read_int(lib->vol_corrupted, dev_num, vol_id,
1317                            &info->corrupted);
1318         if (ret)
1319                 return -1;
1320         info->rsvd_bytes = (long long)info->leb_size * info->rsvd_lebs;
1321
1322         ret = vol_read_data(lib->vol_name, dev_num, vol_id, &info->name,
1323                             UBI_VOL_NAME_MAX + 2);
1324         if (ret < 0)
1325                 return -1;
1326
1327         info->name[ret - 1] = '\0';
1328         return 0;
1329 }
1330
1331 int ubi_get_vol_info(libubi_t desc, const char *node, struct ubi_vol_info *info)
1332 {
1333         int err, vol_id = 0, dev_num = 0;
1334         struct libubi *lib = (struct libubi *)desc;
1335
1336         err = ubi_probe_node(desc, node);
1337         if (err != 2) {
1338                 if (err == 1)
1339                         errno = ENODEV;
1340                 return -1;
1341         }
1342
1343         if (vol_node2nums(lib, node, &dev_num, &vol_id))
1344                 return -1;
1345
1346         return ubi_get_vol_info1(desc, dev_num, vol_id, info);
1347 }
1348
1349 int ubi_get_vol_info1_nm(libubi_t desc, int dev_num, const char *name,
1350                          struct ubi_vol_info *info)
1351 {
1352         int i, err;
1353         unsigned int nlen = strlen(name);
1354         struct ubi_dev_info dev_info;
1355
1356         if (nlen == 0) {
1357                 errmsg("bad \"name\" input parameter");
1358                 errno = EINVAL;
1359                 return -1;
1360         }
1361
1362         err = ubi_get_dev_info1(desc, dev_num, &dev_info);
1363         if (err)
1364                 return err;
1365
1366         for (i = dev_info.lowest_vol_id;
1367              i <= dev_info.highest_vol_id; i++) {
1368                 err = ubi_get_vol_info1(desc, dev_num, i, info);
1369                 if (err == -1) {
1370                         if (errno == ENOENT)
1371                                 continue;
1372                         return -1;
1373                 }
1374
1375                 if (nlen == strlen(info->name) && !strcmp(name, info->name))
1376                         return 0;
1377         }
1378
1379         errno = ENOENT;
1380         return -1;
1381 }
1382
1383 int ubi_set_property(int fd, uint8_t property, uint64_t value)
1384 {
1385         struct ubi_set_vol_prop_req r;
1386
1387         memset(&r, 0, sizeof(struct ubi_set_vol_prop_req));
1388         r.property = property;
1389         r.value = value;
1390
1391         return ioctl(fd, UBI_IOCSETVOLPROP, &r);
1392 }
1393
1394 int ubi_leb_unmap(int fd, int lnum)
1395 {
1396         return ioctl(fd, UBI_IOCEBUNMAP, &lnum);
1397 }
1398
1399 int ubi_is_mapped(int fd, int lnum)
1400 {
1401         return ioctl(fd, UBI_IOCEBISMAP, &lnum);
1402 }