split fs-state back into seperate tools
[project/fstools.git] / ubi.c
1 /*
2  * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License version 2.1
6  * as published by the Free Software Foundation
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  */
13
14 #include <sys/types.h>
15 #include <sys/stat.h>
16 #include <fcntl.h>
17 #include <stdio.h>
18 #include <stdint.h>
19 #include <getopt.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <unistd.h>
23
24 #include "libubi/libubi-tiny.h"
25
26 static int mtd_find_index(char *name)
27 {
28         FILE *fp = fopen("/proc/mtd", "r");
29         char line[256];
30         char *index = NULL;
31
32         if (!fp)
33                 return -1;
34
35         while (!index && fgets(line, sizeof(line), fp)) {
36                 if (strstr(line, name)) {
37                         char *eol = strstr(line, ":");
38
39                         if (!eol)
40                                 continue;
41
42                         *eol = '\0';
43                         index = &line[3];
44                 }
45         }
46
47         fclose(fp);
48
49         if (!index)
50                 return -1;
51
52         return atoi(index);
53 }
54
55 static int mtd_find(char *name, char *ret)
56 {
57         int index = mtd_find_index(name);
58         if (index < 0)
59                 return -1;
60
61         sprintf(ret, "/dev/mtd%d", index);
62
63         return 0;
64 }
65
66 static int ubi_find(libubi_t libubi, char *name, char *ret)
67 {
68         int index = mtd_find_index(name);
69         int ubi = 0;
70
71         if (index < 0)
72                 return -1;
73
74         if (mtd_num2ubi_dev(libubi, index, &ubi)) {
75                 fprintf(stderr, "failed to get ubi node for %s\n", name);
76                 return -1;
77         }
78         sprintf(ret, "/dev/ubi%d", ubi);
79
80         return 0;
81 }
82
83 static int ubi_find_mtd(libubi_t libubi, char *name, char *ret)
84 {
85         struct ubi_dev_info info;
86
87         if (ubi_find(libubi, name, ret))
88                 return -1;
89
90         if (ubi_get_dev_info(libubi, ret, &info))
91                 return -1;
92
93         sprintf(ret, "/dev/mtd%d", info.mtd_num);
94
95         return 0;
96 }
97
98 static int volume_find(libubi_t libubi, char *name, char *ret)
99 {
100         int index = mtd_find_index(name);
101         struct ubi_vol_info vol;
102         int ubi = 0;
103
104         if (index < 0)
105                 return -1;
106
107         if (mtd_num2ubi_dev(libubi, index, &ubi)) {
108                 fprintf(stderr, "failed to get ubi node for %s\n", name);
109                 return -1;
110         }
111
112         if (ubi_get_vol_info1_nm(libubi, ubi, name, &vol)) {
113                 fprintf(stderr, "failed to get ubi volume info for %s\n", name);
114                 return -1;
115         }
116
117         sprintf(ret, "/dev/ubi%d_%d", ubi, vol.vol_id);
118
119         return 0;
120 }
121
122 static int main_image(char *partition, char *image, char *overlay)
123 {
124         libubi_t libubi;
125         int err;
126         char mtd[64];
127         char part[64];
128         char node[64];
129         char volume[64];
130         char _data[64];
131         char *data = NULL;
132
133         if (mtd_find(partition, part)) {
134                 fprintf(stderr, "failed to find mtd partition %s\n", partition);
135                 return -1;
136         }
137         if (overlay && !mtd_find(overlay, _data))
138                 data = _data;
139
140         libubi = libubi_open();
141         if (!libubi) {
142                 fprintf(stderr, "cannot open libubi");
143                 return -1;
144         }
145
146         if (ubi_find_mtd(libubi, partition, mtd)) {
147                 fprintf(stderr, "failed to find mtd parent %s\n", partition);
148                 return -1;
149         }
150
151         if (ubi_find(libubi, partition, node)) {
152                 fprintf(stderr, "failed to find ubi volume %s\n", partition);
153                 return -1;
154         }
155
156         if (volume_find(libubi, partition, volume)) {
157                 fprintf(stderr, "failed to find ubi volume %s\n", partition);
158                 return -1;
159         }
160
161         err = ubidetach(libubi, mtd);
162         if (err) {
163                 fprintf(stderr, "cannot detach \"%s\"", mtd);
164                 return -1;
165         }
166
167         err = ubiattach(libubi, mtd);
168         if (err) {
169                 fprintf(stderr, "cannot detach \"%s\"", mtd);
170                 return -1;
171         }
172
173         if (data) {
174                 err = ubirmvol(libubi, node, overlay);
175                 if (err) {
176                         fprintf(stderr, "cannot remove \"%s\"", node);
177                         return -1;
178                 }
179         }
180
181         err = ubiupdatevol(libubi, volume, image);
182         if (err) {
183                 fprintf(stderr, "cannot update \"%s\"", volume);
184                 return -1;
185         }
186
187         if (overlay) {
188                 err = ubimkvol(libubi, node, overlay, 1);
189                 if (err) {
190                         fprintf(stderr, "cannot make \"%s\"", node);
191                         return -1;
192                 }
193         }
194
195         libubi_close(libubi);
196
197         return err;
198 }
199
200 static int main_info(void)
201 {
202         struct ubi_info info;
203         libubi_t libubi;
204         int i;
205
206         libubi = libubi_open();
207         if (!libubi) {
208                 fprintf(stderr, "cannot open libubi");
209                 return -1;
210         }
211
212         if (ubi_get_info(libubi, &info)) {
213                 fprintf(stderr, "failed to get info\n");
214                 return -1;
215         }
216
217         for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
218                 struct ubi_dev_info dinfo;
219                 char ubi[64];
220                 int j;
221
222                 sprintf(ubi, "/dev/ubi%d", i);
223                 if (ubi_get_dev_info(libubi, ubi, &dinfo))
224                         continue;
225                 printf("device - %s\n  size: %lldBytes\n  bad blocks: %d\n",
226                         &ubi[5], dinfo.total_bytes, dinfo.bad_count);
227                 for (j = dinfo.lowest_vol_id; j <= dinfo.highest_vol_id; j++) {
228                         struct ubi_vol_info vinfo;
229
230                         sprintf(ubi, "/dev/ubi%d_%d", i, j);
231                         if (ubi_get_vol_info(libubi, ubi, &vinfo))
232                                 continue;
233                         printf("  volume - %s\n", &ubi[5]);
234                         printf("\tname: %s\n", vinfo.name);
235                         printf("\tsize: %lld\n", vinfo.data_bytes);
236                 }
237         }
238
239         libubi_close(libubi);
240
241         return 0;
242 }
243
244 static int print_usage(void)
245 {
246         printf("ubi info\n");
247         printf("ubi kernel <image.kernel.ubi>\n");
248         printf("ubi rootfs <image.rootfs.ubi>\n");
249         printf("ubi overlay <image.rootfs-overlay.ubi>\n");
250
251         return -1;
252 }
253
254 int main(int argc, char **argv)
255 {
256         if (argc > 1 && !strcmp(argv[1], "info"))
257                 return main_info();
258
259         if (argc < 3)
260                 return print_usage();
261
262         if (!strcmp(argv[1], "kernel")) {
263                 return main_image("kernel", argv[2], NULL);
264
265         } else if (!strcmp(argv[1], "rootfs")) {
266                 return main_image("rootfs", argv[2], NULL);
267
268         } else if (!strcmp(argv[1], "overlay")) {
269                 return main_image("rootfs", argv[2], "rootfs_data");
270         }
271
272         return -1;
273 }
274