skip ubi volume detection if ubifs is not present (fall back to mtd in that case)
[project/fstools.git] / libubi / libubi-tiny.c
1 /*
2  * Copyright (C) 2007 Nokia Corporation.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License version 2 as published by
6  * the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License along with
14  * this program; if not, write to the Free Software Foundation, Inc., 51
15  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
16  */
17
18 /*
19  * An utility to delete UBI devices (detach MTD devices from UBI).
20  *
21  * Author: Artem Bityutskiy
22  */
23
24 #define PROGRAM_NAME    "ubidetach"
25 #define VERSION "owrt-fstools"
26
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
30 #include <stdio.h>
31 #include <stdint.h>
32 #include <getopt.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include "libubi-tiny.h"
38
39 #define DEFAULT_CTRL_DEV "/dev/ubi_ctrl"
40
41 static int ubi_write(char *node, int fd, const void *buf, int len)
42 {
43         int ret;
44
45         while (len) {
46                 ret = write(fd, buf, len);
47                 if (ret < 0) {
48                         if (errno == EINTR) {
49                                 fprintf(stderr, "do not interrupt me!");
50                                 continue;
51                         }
52                         fprintf(stderr, "cannot write %d bytes to volume \"%s\"", len, node);
53                         return -1;
54                 }
55
56                 if (ret == 0) {
57                         fprintf(stderr, "cannot write %d bytes to volume \"%s\"", len, node);
58                         return -1;
59                 }
60                 len -= ret;
61                 buf += ret;
62         }
63
64         return 0;
65 }
66
67 static int update_volume(libubi_t libubi, struct ubi_vol_info *vol_info, char *node, char *img, int skip)
68 {
69         int err, fd, ifd;
70         long long bytes;
71         char *buf;
72         struct stat st;
73
74         buf = malloc(vol_info->leb_size);
75         if (!buf) {
76                 fprintf(stderr, "cannot allocate %d bytes of memory", vol_info->leb_size);
77                 return -1;
78         }
79         err = stat(img, &st);
80         if (err < 0) {
81                 fprintf(stderr, "stat failed on \"%s\"", img);
82                 goto out_free;
83         }
84
85         bytes = st.st_size - skip;
86
87         if (bytes > vol_info->rsvd_bytes) {
88                 fprintf(stderr, "\"%s\" (size %lld) will not fit volume \"%s\" (size %lld)",
89                        img, bytes, node, vol_info->rsvd_bytes);
90                 goto out_free;
91         }
92
93         fd = open(node, O_RDWR);
94         if (fd == -1) {
95                 fprintf(stderr, "cannot open UBI volume \"%s\"", node);
96                 goto out_free;
97         }
98
99         ifd = open(img, O_RDONLY);
100         if (ifd == -1) {
101                 fprintf(stderr, "cannot open \"%s\"", img);
102                 goto out_close1;
103         }
104
105         if (skip && lseek(ifd, skip, SEEK_CUR) == -1) {
106                 fprintf(stderr, "lseek input by %d failed", skip);
107                 goto out_close;
108         }
109
110         err = ubi_update_start(libubi, fd, bytes);
111         if (err) {
112                 fprintf(stderr, "cannot start volume \"%s\" update", node);
113                 goto out_close;
114         }
115
116         while (bytes) {
117                 ssize_t ret;
118                 int to_copy = vol_info->leb_size;
119                 if (to_copy > bytes)
120                         to_copy = bytes;
121
122                 ret = read(ifd, buf, to_copy);
123                 if (ret <= 0) {
124                         if (errno == EINTR) {
125                                 fprintf(stderr, "do not interrupt me!");
126                                 continue;
127                         } else {
128                                 fprintf(stderr, "cannot read %d bytes from \"%s\"",
129                                                 to_copy, img);
130                                 goto out_close;
131                         }
132                 }
133
134                 err = ubi_write(node, fd, buf, ret);
135                 if (err)
136                         goto out_close;
137                 bytes -= ret;
138         }
139
140         close(ifd);
141         close(fd);
142         free(buf);
143         return 0;
144
145 out_close:
146         close(ifd);
147 out_close1:
148         close(fd);
149 out_free:
150         free(buf);
151         return -1;
152 }
153
154 int ubiattach(libubi_t libubi, char *mtd)
155 {
156         struct ubi_attach_request req = {
157                 .dev_num = UBI_DEV_NUM_AUTO,
158                 .mtd_num = -1,
159                 .vid_hdr_offset = 0,
160                 .max_beb_per1024 = 0,
161                 .mtd_dev_node = mtd,
162         };
163         int err = ubi_attach(libubi, DEFAULT_CTRL_DEV, &req);
164
165         if (err) {
166                 fprintf(stderr, "cannot attach \"%s\"", mtd);
167                 return err;
168         }
169
170         return 0;
171 }
172
173 int ubidetach(libubi_t libubi, char *mtd)
174 {
175         return ubi_detach(libubi, DEFAULT_CTRL_DEV, mtd);
176 }
177
178 int ubirsvol(libubi_t libubi, char *node, char *name, int bytes)
179 {
180         struct ubi_dev_info dev_info;
181         struct ubi_vol_info vol_info;
182         int err = ubi_get_dev_info(libubi, node, &dev_info);
183
184         if (err) {
185                 fprintf(stderr, "cannot get information about UBI device \"%s\"",
186                         node);
187                 return -1;
188         }
189         err = ubi_get_vol_info1_nm(libubi, dev_info.dev_num, name, &vol_info);
190         if (err) {
191                 fprintf(stderr, "cannot find UBI volume \"%s\"", name);
192                 return -1;
193         }
194
195         err = ubi_rsvol(libubi, node, vol_info.vol_id, bytes);
196         if (err) {
197                 fprintf(stderr, "cannot UBI resize volume");
198                 return -1;
199         }
200
201         return 0;
202 }
203
204 int ubirmvol(libubi_t libubi, char *node, char *name)
205 {
206         struct ubi_dev_info dev_info;
207         struct ubi_vol_info vol_info;
208         int err = ubi_get_dev_info(libubi, node, &dev_info);
209
210         if (err) {
211                 fprintf(stderr, "cannot get information about UBI device \"%s\"",
212                         node);
213                 return -1;
214         }
215
216         err = ubi_get_vol_info1_nm(libubi, dev_info.dev_num, name, &vol_info);
217         if (err) {
218                 fprintf(stderr, "cannot find UBI volume \"%s\"", name);
219                 return -1;
220         }
221
222         err = ubi_rmvol(libubi, node, vol_info.vol_id);
223         if (err) {
224                 fprintf(stderr, "cannot UBI remove volume");
225                 return -1;
226         }
227
228         return 0;
229 }
230
231 int ubimkvol(libubi_t libubi, char *node, char *name, int maxavs)
232 {
233         struct ubi_dev_info dev_info;
234         struct ubi_vol_info vol_info;
235         struct ubi_mkvol_request req;
236         int err = ubi_get_dev_info(libubi, node, &dev_info);
237
238         if (err) {
239                 fprintf(stderr, "cannot get information about UBI device \"%s\"",
240                         node);
241                 return -1;
242         }
243
244         if (dev_info.avail_bytes == 0) {
245                 fprintf(stderr, "UBI device does not have free logical eraseblocks");
246                 return -1;
247         }
248
249         if (maxavs)
250                 printf("Set volume size to %lld\n", dev_info.avail_bytes);
251
252         req.vol_id = UBI_VOL_NUM_AUTO;
253         req.alignment = 1;
254         req.bytes = dev_info.avail_bytes;
255         req.vol_type = UBI_DYNAMIC_VOLUME;
256         req.name = name;
257
258         err = ubi_mkvol(libubi, node, &req);
259         if (err < 0) {
260                 fprintf(stderr, "cannot UBI create volume");
261                 return -1;
262         }
263
264         /* Print information about the created device */
265         err = ubi_get_vol_info1(libubi, dev_info.dev_num, req.vol_id, &vol_info);
266         if (err) {
267                 fprintf(stderr, "cannot get information about newly created UBI volume");
268                 return -1;
269         }
270
271         printf("Volume ID %d, size %d LEBs (", vol_info.vol_id, vol_info.rsvd_lebs);
272         ubiutils_print_bytes(vol_info.rsvd_bytes, 0);
273         printf("), LEB size ");
274         ubiutils_print_bytes(vol_info.leb_size, 1);
275         printf(", %s, name \"%s\", alignment %d\n",
276                 req.vol_type == UBI_DYNAMIC_VOLUME ? "dynamic" : "static",
277                 vol_info.name, vol_info.alignment);
278
279         return 0;
280 }
281
282 int ubiupdatevol(libubi_t libubi, char *node, char *file)
283 {
284         struct ubi_vol_info vol_info;
285         int err = ubi_get_vol_info(libubi, node, &vol_info);
286
287         if (err) {
288                 fprintf(stderr, "cannot get information about UBI volume \"%s\"",
289                         node);
290                 return -1;
291         }
292
293         return update_volume(libubi, &vol_info, node, file, 0);
294 }
295
296 int ubitruncatevol(libubi_t libubi, char *node)
297 {
298         int err, fd;
299
300         fd = open(node, O_RDWR);
301         if (fd == -1) {
302                 fprintf(stderr, "cannot open \"%s\"", node);
303                 return -1;
304         }
305
306         err = ubi_update_start(libubi, fd, 0);
307         if (err) {
308                 fprintf(stderr, "cannot truncate volume \"%s\"", node);
309                 close(fd);
310                 return -1;
311         }
312
313         close(fd);
314         return 0;
315 }