• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/fstools/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 <libubox/ulog.h>
 25 
 26 #include "libubi/libubi-tiny.h"
 27 
 28 static int print_usage(void)
 29 {
 30         printf("ubi info\n");
 31         printf("ubi detach kernel|rootfs\n");
 32         printf("ubi kernel <image.kernel.ubi>\n");
 33         printf("ubi rootfs <image.rootfs.ubi>\n");
 34         printf("ubi overlay <image.rootfs-overlay.ubi>\n");
 35 
 36         return -1;
 37 }
 38 
 39 static int mtd_find_index(char *name)
 40 {
 41         FILE *fp = fopen("/proc/mtd", "r");
 42         char line[256];
 43         char *index = NULL;
 44 
 45         if (!fp)
 46                 return -1;
 47 
 48         while (!index && fgets(line, sizeof(line), fp)) {
 49                 if (strstr(line, name)) {
 50                         char *eol = strstr(line, ":");
 51 
 52                         if (!eol)
 53                                 continue;
 54 
 55                         *eol = '\0';
 56                         index = &line[3];
 57                 }
 58         }
 59 
 60         fclose(fp);
 61 
 62         if (!index)
 63                 return -1;
 64 
 65         return atoi(index);
 66 }
 67 
 68 static int mtd_find(char *name, char *ret)
 69 {
 70         int index = mtd_find_index(name);
 71         if (index < 0)
 72                 return -1;
 73 
 74         sprintf(ret, "/dev/mtd%d", index);
 75 
 76         return 0;
 77 }
 78 
 79 static int ubi_find(libubi_t libubi, char *name, char *ret)
 80 {
 81         int index = mtd_find_index(name);
 82         int ubi = 0;
 83 
 84         while (ubi_dev_present(libubi, ubi))
 85         {
 86                 struct ubi_dev_info info;
 87 
 88                 if (ubi_get_dev_info1(libubi, ubi++, &info))
 89                         continue;
 90 
 91                 if (info.mtd_num != index)
 92                         continue;
 93 
 94                 sprintf(ret, "/dev/ubi%d", info.dev_num);
 95 
 96                 return 0;
 97         }
 98 
 99         return -1;
100 }
101 
102 static int volume_find(libubi_t libubi, char *name, char *ret)
103 {
104         int index = mtd_find_index(name);
105         struct ubi_vol_info vol;
106         int ubi = 0;
107 
108         if (index < 0)
109                 return -1;
110 
111         if (mtd_num2ubi_dev(libubi, index, &ubi)) {
112                 ULOG_ERR("failed to get ubi node for %s\n", name);
113                 return -1;
114         }
115 
116         if (ubi_get_vol_info1_nm(libubi, ubi, name, &vol)) {
117                 ULOG_ERR("failed to get ubi volume info for %s\n", name);
118                 return -1;
119         }
120 
121         sprintf(ret, "/dev/ubi%d_%d", ubi, vol.vol_id);
122 
123         return 0;
124 }
125 
126 static int main_detach(char *type)
127 {
128         libubi_t libubi;
129         char mtd[64];
130         int err;
131 
132         if (!strcmp(type, "kernel"))
133                 err = mtd_find("kernel_ubi", mtd);
134         else if (!strcmp(type, "rootfs"))
135                 err = mtd_find("rootfs_ubi", mtd);
136         else
137                 return print_usage();
138 
139         if (err) {
140                 ULOG_ERR("MTD partition '%s_ubi' not found\n", type);
141                 return -1;
142         }
143 
144         libubi = libubi_open();
145         if (!libubi) {
146                 ULOG_ERR("cannot open libubi");
147                 return -1;
148         }
149 
150         err = ubidetach(libubi, mtd);
151         if (err) {
152                 ULOG_ERR("cannot detach \"%s\"", mtd);
153                 return -1;
154         }
155 
156         return 0;
157 }
158 
159 static int main_image(char *partition, char *image, char *overlay)
160 {
161         libubi_t libubi;
162         struct stat s;
163         int err;
164         char mtd[64];
165         char _part[64];
166         char node[64];
167         char volume[64];
168         char _data[64];
169         char *data = NULL;
170 
171         if (stat(image, &s)) {
172                 ULOG_ERR("image not found %s\n", image);
173                 return -1;
174         }
175 
176         if (!strcmp(partition, "kernel"))
177                 err = mtd_find("kernel", _part);
178         else
179                 err = mtd_find("rootfs", _part);
180 
181         if (overlay && !mtd_find(overlay, _data))
182                 data = _data;
183 
184         libubi = libubi_open();
185         if (!libubi) {
186                 ULOG_ERR("cannot open libubi");
187                 return -1;
188         }
189 
190         if (!strcmp(partition, "kernel"))
191                 err = mtd_find("kernel_ubi", mtd);
192         else
193                 err = mtd_find("rootfs_ubi", mtd);
194         if (err) {
195                 ULOG_ERR("MTD partition '%s_ubi' not found\n", partition);
196                 return -1;
197         }
198 
199         if (!strcmp(partition, "kernel"))
200                 err = ubi_find(libubi, "kernel_ubi", node);
201         else
202                 err = ubi_find(libubi, "rootfs_ubi", node);
203         if (err) {
204                 ULOG_ERR("UBI volume '%s' not found\n", partition);
205                 return -1;
206         }
207 
208         err = ubidetach(libubi, mtd);
209         if (err) {
210                 ULOG_ERR("cannot detach \"%s\"", mtd);
211                 return -1;
212         }
213 
214         err = ubiattach(libubi, mtd);
215         if (err) {
216                 ULOG_ERR("cannot attach \"%s\"", mtd);
217                 return -1;
218         }
219 
220         if (data) {
221                 err = ubirmvol(libubi, node, overlay);
222                 if (err) {
223                         ULOG_ERR("cannot remove \"%s\"", node);
224                         return -1;
225                 }
226         }
227 
228         if (volume_find(libubi, partition, volume) < 0) {
229                 ULOG_ERR("UBI volume '%s' not found\n", partition);
230                 return -1;
231         }
232 
233         err = ubirsvol(libubi, node, partition, s.st_size);
234         if (err) {
235                 ULOG_ERR("cannot resize \"%s\"", partition);
236                 return -1;
237         }
238 
239         err = ubiupdatevol(libubi, volume, image);
240         if (err) {
241                 ULOG_ERR("cannot update \"%s\"", volume);
242                 return -1;
243         }
244 
245         if (overlay) {
246                 err = ubimkvol(libubi, node, overlay, 1);
247                 if (err) {
248                         ULOG_ERR("cannot make \"%s\"", overlay);
249                         return -1;
250                 }
251         }
252 
253         libubi_close(libubi);
254 
255         return err;
256 }
257 
258 static int main_info(void)
259 {
260         struct ubi_info info;
261         libubi_t libubi;
262         int i;
263 
264         libubi = libubi_open();
265         if (!libubi) {
266                 ULOG_ERR("cannot open libubi");
267                 return -1;
268         }
269 
270         if (ubi_get_info(libubi, &info)) {
271                 ULOG_ERR("failed to get info\n");
272                 return -1;
273         }
274 
275         for (i = info.lowest_dev_num; i <= info.highest_dev_num; i++) {
276                 struct ubi_dev_info dinfo;
277                 char ubi[64];
278                 int j;
279 
280                 sprintf(ubi, "/dev/ubi%d", i);
281                 if (ubi_get_dev_info(libubi, ubi, &dinfo))
282                         continue;
283                 printf("device - %s\n  size: %lldBytes\n  bad blocks: %d\n",
284                        &ubi[5], dinfo.total_bytes, dinfo.bad_count);
285                 for (j = dinfo.lowest_vol_id; j <= dinfo.highest_vol_id; j++) {
286                         struct ubi_vol_info vinfo;
287 
288                         sprintf(ubi, "/dev/ubi%d_%d", i, j);
289                         if (ubi_get_vol_info(libubi, ubi, &vinfo))
290                                 continue;
291                         printf("  volume - %s\n", &ubi[5]);
292                         printf("\tname: %s\n", vinfo.name);
293                         printf("\tsize: %lld\n", vinfo.data_bytes);
294                 }
295         }
296 
297         libubi_close(libubi);
298 
299         return 0;
300 }
301 
302 int main(int argc, char **argv)
303 {
304         if (argc > 1 && !strcmp(argv[1], "info"))
305                 return main_info();
306 
307         if (argc < 3)
308                 return print_usage();
309 
310         if (!strcmp(argv[1], "kernel")) {
311                 return main_image("kernel", argv[2], NULL);
312 
313         } else if (!strcmp(argv[1], "rootfs")) {
314                 return main_image("rootfs", argv[2], NULL);
315 
316         } else if (!strcmp(argv[1], "overlay")) {
317                 return main_image("rootfs", argv[2], "rootfs_data");
318 
319         } else if (!strcmp(argv[1], "detach")) {
320                 return main_detach(argv[2]);
321         }
322 
323         return -1;
324 }
325 
326 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt