yaffs-vfs-multi.c: Handle search context properly to prevent leaking
[yaffs2.git] / utils / mkyaffsimage.c
1 /*
2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
3  *
4  * Copyright (C) 2002-2018 Aleph One Ltd.
5  *
6  * Created by Charles Manning <charles@aleph1.co.uk>
7  * Nick Bane modifications flagged NCB
8  * Endian handling patches by James Ng
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14
15 /*
16  * makeyaffsimage.c
17  *
18  * Makes a YAFFS file system image that can be used to load up a file system.
19  */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <fcntl.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <dirent.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include "yaffs_ecc.h"
30 #include "yaffs_guts.h"
31
32
33 #define MAX_OBJECTS 10000
34
35 const char * mkyaffsimage_c_version = "$Id: mkyaffsimage.c,v 1.7 2003/07/16 03:00:48 charles Exp $";
36
37
38 typedef struct
39 {
40         dev_t dev;
41         ino_t ino;
42         int   obj;
43 } objItem;
44
45
46 static objItem obj_list[MAX_OBJECTS];
47 static int obj_alloc_id = YAFFS_NOBJECT_BUCKETS + 1;
48
49 static int n_obj, nDirectories, nPages;
50
51 static int outFile;
52
53 static int error;
54
55 static int convert_endian = 0;
56
57 static int obj_compare(const void *a, const void * b)
58 {
59   objItem *oa, *ob;
60
61   oa = (objItem *)a;
62   ob = (objItem *)b;
63
64   if(oa->dev < ob->dev) return -1;
65   if(oa->dev > ob->dev) return 1;
66   if(oa->ino < ob->ino) return -1;
67   if(oa->ino > ob->ino) return 1;
68
69   return 0;
70 }
71
72
73 static void add_obj_to_list(dev_t dev, ino_t ino, int obj)
74 {
75         if(n_obj < MAX_OBJECTS)
76         {
77                 obj_list[n_obj].dev = dev;
78                 obj_list[n_obj].ino = ino;
79                 obj_list[n_obj].obj = obj;
80                 n_obj++;
81                 qsort(obj_list,n_obj,sizeof(objItem),obj_compare);
82
83         }
84         else
85         {
86                 // oops! not enough space in the object array
87                 fprintf(stderr,"Not enough space in object array\n");
88                 exit(2);
89         }
90 }
91
92
93 static int find_obj_in_list(dev_t dev, ino_t ino)
94 {
95         objItem *i = NULL;
96         objItem test;
97
98         test.dev = dev;
99         test.ino = ino;
100
101         if(n_obj > 0)
102         {
103                 i = bsearch(&test,obj_list,n_obj,sizeof(objItem),obj_compare);
104         }
105
106         if(i)
107         {
108                 return i->obj;
109         }
110         return -1;
111 }
112
113 #if 0
114 // NCB added 10/9/2002
115 static u16 yaffs_calc_name_sum(const char *name)
116 {
117         u16 sum = 0;
118         u16 i = 1;
119
120         u8 *bname = (u8 *)name;
121
122         while (*bname)
123         {
124                 sum += (*bname) * i;
125                 i++;
126                 bname++;
127         }
128         return sum;
129 }
130 #endif
131
132 static void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare)
133 {
134         yaffs_ecc_calc(data , spare->ecc1);
135         yaffs_ecc_calc(&data[256] , spare->ecc2);
136 }
137
138 static void yaffs_calc_tags_ecc(struct yaffs_tags *tags)
139 {
140         // Todo don't do anything yet. Need to calculate ecc
141         unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes;
142         unsigned  i,j;
143         unsigned  ecc = 0;
144         unsigned bit = 0;
145
146     // Clear ECC fields
147     if (!convert_endian)
148     {
149             tags->ecc = 0;
150     }
151     else
152     {
153         // Because we're in "munged tag" mode, we have to clear it manually
154         b[6] &= 0xC0;
155         b[7] &= 0x03;
156     }
157
158         for(i = 0; i < 8; i++)
159         {
160 // NCB modified 20-9-02         for(j = 1; j &0x7f; j<<=1)
161                 for(j = 1; j &0xff; j<<=1)
162                 {
163                         bit++;
164                         if(b[i] & j)
165                         {
166                                 ecc ^= bit;
167                         }
168                 }
169         }
170
171         // Write out ECC
172     if (!convert_endian)
173     {
174         tags->ecc = ecc;
175     }
176     else
177     {
178             // We have to munge the ECC again.
179             b[6] |= ((ecc >> 6) & 0x3F);
180         b[7] |= ((ecc & 0x3F) << 2);
181     }
182 }
183 static void yaffs_load_tags_to_spare(struct yaffs_spare *sparePtr, struct yaffs_tags *tagsPtr)
184 {
185         union yaffs_tags_union *tu = (union yaffs_tags_union *)tagsPtr;
186
187         //yaffs_calc_tags_ecc(tagsPtr);
188
189         sparePtr->tb0 = tu->as_bytes[0];
190         sparePtr->tb1 = tu->as_bytes[1];
191         sparePtr->tb2 = tu->as_bytes[2];
192         sparePtr->tb3 = tu->as_bytes[3];
193         sparePtr->tb4 = tu->as_bytes[4];
194         sparePtr->tb5 = tu->as_bytes[5];
195         sparePtr->tb6 = tu->as_bytes[6];
196         sparePtr->tb7 = tu->as_bytes[7];
197 }
198
199 /* This little function converts a little endian tag to a big endian tag.
200  * NOTE: The tag is not usable after this other than calculating the CRC
201  * with.
202  */
203 static void little_to_big_endian(struct yaffs_tags *tagsPtr)
204 {
205     union yaffs_tags_union * tags = (union yaffs_tags_union* )tagsPtr; // Work in bytes.
206     union yaffs_tags_union   temp;
207
208     memset(&temp, 0, sizeof(temp));
209     // Ick, I hate magic numbers.
210     temp.as_bytes[0] = ((tags->as_bytes[2] & 0x0F) << 4) | ((tags->as_bytes[1] & 0xF0) >> 4);
211     temp.as_bytes[1] = ((tags->as_bytes[1] & 0x0F) << 4) | ((tags->as_bytes[0] & 0xF0) >> 4);
212     temp.as_bytes[2] = ((tags->as_bytes[0] & 0x0F) << 4) | ((tags->as_bytes[2] & 0x30) >> 2) | ((tags->as_bytes[3] & 0xC0) >> 6);
213     temp.as_bytes[3] = ((tags->as_bytes[3] & 0x3F) << 2) | ((tags->as_bytes[2] & 0xC0) >> 6);
214     temp.as_bytes[4] = ((tags->as_bytes[6] & 0x03) << 6) | ((tags->as_bytes[5] & 0xFC) >> 2);
215     temp.as_bytes[5] = ((tags->as_bytes[5] & 0x03) << 6) | ((tags->as_bytes[4] & 0xFC) >> 2);
216     temp.as_bytes[6] = ((tags->as_bytes[4] & 0x03) << 6) | (tags->as_bytes[7] & 0x3F);
217     temp.as_bytes[7] = (tags->as_bytes[6] & 0xFC) | ((tags->as_bytes[7] & 0xC0) >> 6);
218
219     // Now copy it back.
220     tags->as_bytes[0] = temp.as_bytes[0];
221     tags->as_bytes[1] = temp.as_bytes[1];
222     tags->as_bytes[2] = temp.as_bytes[2];
223     tags->as_bytes[3] = temp.as_bytes[3];
224     tags->as_bytes[4] = temp.as_bytes[4];
225     tags->as_bytes[5] = temp.as_bytes[5];
226     tags->as_bytes[6] = temp.as_bytes[6];
227     tags->as_bytes[7] = temp.as_bytes[7];
228 }
229
230 static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes)
231 {
232         struct yaffs_tags t;
233         struct yaffs_spare s;
234
235         error = write(outFile,data,512);
236         if(error < 0) return error;
237
238         memset(&t,0xff,sizeof (struct yaffs_tags));
239         memset(&s,0xff,sizeof (struct yaffs_spare));
240
241         t.chunk_id = chunk_id;
242         t.serial_number = 0;
243         t.n_bytes_lsb = n_bytes;
244         t.obj_id = obj_id;
245
246     if (convert_endian)
247     {
248         little_to_big_endian(&t);
249     }
250
251         yaffs_calc_tags_ecc(&t);
252         yaffs_load_tags_to_spare(&s,&t);
253         yaffs_calc_ecc(data,&s);
254
255         nPages++;
256
257         return write(outFile,&s,sizeof(struct yaffs_spare));
258
259 }
260
261 #define SWAP32(x)   ((((x) & 0x000000FF) << 24) | \
262                      (((x) & 0x0000FF00) << 8 ) | \
263                      (((x) & 0x00FF0000) >> 8 ) | \
264                      (((x) & 0xFF000000) >> 24))
265
266 #define SWAP16(x)   ((((x) & 0x00FF) << 8) | \
267                      (((x) & 0xFF00) >> 8))
268
269 // This one is easier, since the types are more standard. No funky shifts here.
270 static void object_header_little_to_big_endian(struct yaffs_obj_hdr* oh)
271 {
272     oh->type = SWAP32(oh->type); // GCC makes enums 32 bits.
273     oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int
274     oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // u16 - Not used, but done for completeness.
275     // name = skip. Char array. Not swapped.
276     oh->yst_mode = SWAP32(oh->yst_mode);
277
278     // Regular POSIX.
279     oh->yst_uid = SWAP32(oh->yst_uid);
280     oh->yst_gid = SWAP32(oh->yst_gid);
281     oh->yst_atime = SWAP32(oh->yst_atime);
282     oh->yst_mtime = SWAP32(oh->yst_mtime);
283     oh->yst_ctime = SWAP32(oh->yst_ctime);
284
285     oh->file_size_low = SWAP32(oh->file_size_low); // Aiee. An int... signed, at that!
286     oh->equiv_id = SWAP32(oh->equiv_id);
287     // alias  - char array.
288     oh->yst_rdev = SWAP32(oh->yst_rdev);
289
290     oh->win_ctime[0] = SWAP32(oh->win_ctime[0]);
291     oh->win_ctime[1] = SWAP32(oh->win_ctime[1]);
292     oh->win_atime[0] = SWAP32(oh->win_atime[0]);
293     oh->win_atime[1] = SWAP32(oh->win_atime[1]);
294     oh->win_mtime[0] = SWAP32(oh->win_mtime[0]);
295     oh->win_mtime[1] = SWAP32(oh->win_mtime[1]);
296
297     oh->reserved[0] = SWAP32(oh->reserved[0]);
298
299     oh->inband_shadowed_obj_id = SWAP32(oh->inband_shadowed_obj_id);
300     oh->inband_is_shrink = SWAP32(oh->inband_is_shrink);
301     oh->shadows_obj = SWAP32(oh->shadows_obj);
302     oh->is_shrink = SWAP32(oh->is_shrink);
303 }
304
305 static int write_object_header(int obj_id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias)
306 {
307         u8 bytes[512];
308
309
310         struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes;
311
312         memset(bytes,0xff,512);
313
314         oh->type = t;
315
316         oh->parent_obj_id = parent;
317
318         strncpy(oh->name,name,YAFFS_MAX_NAME_LENGTH);
319
320
321         if(t != YAFFS_OBJECT_TYPE_HARDLINK)
322         {
323                 oh->yst_mode = s->st_mode;
324                 oh->yst_uid = s->st_uid;
325 // NCB 12/9/02          oh->yst_gid = s->yst_uid;
326                 oh->yst_gid = s->st_gid;
327                 oh->yst_atime = s->st_atime;
328                 oh->yst_mtime = s->st_mtime;
329                 oh->yst_ctime = s->st_ctime;
330                 oh->yst_rdev  = s->st_rdev;
331         }
332
333         if(t == YAFFS_OBJECT_TYPE_FILE)
334         {
335                 oh->file_size_low = s->st_size;
336         }
337
338         if(t == YAFFS_OBJECT_TYPE_HARDLINK)
339         {
340                 oh->equiv_id = equivalentObj;
341         }
342
343         if(t == YAFFS_OBJECT_TYPE_SYMLINK)
344         {
345                 strncpy(oh->alias,alias,YAFFS_MAX_ALIAS_LENGTH);
346         }
347
348     if (convert_endian)
349     {
350         object_header_little_to_big_endian(oh);
351     }
352
353         return write_chunk(bytes,obj_id,0,0xffff);
354
355 }
356
357
358 static int process_directory(int parent, const char *path)
359 {
360
361         DIR *dir;
362         struct dirent *entry;
363
364         nDirectories++;
365
366         dir = opendir(path);
367
368         if(dir)
369         {
370                 while((entry = readdir(dir)) != NULL)
371                 {
372
373                         /* Ignore . and .. */
374                         if(strcmp(entry->d_name,".") &&
375                            strcmp(entry->d_name,".."))
376                         {
377                                 char full_name[500];
378                                 struct stat stats;
379                                 int equivalentObj;
380                                 int newObj;
381
382                                 sprintf(full_name,"%s/%s",path,entry->d_name);
383
384                                 lstat(full_name,&stats);
385
386                                 if(S_ISLNK(stats.st_mode) ||
387                                     S_ISREG(stats.st_mode) ||
388                                     S_ISDIR(stats.st_mode) ||
389                                     S_ISFIFO(stats.st_mode) ||
390                                     S_ISBLK(stats.st_mode) ||
391                                     S_ISCHR(stats.st_mode) ||
392                                     S_ISSOCK(stats.st_mode))
393                                 {
394
395                                         newObj = obj_alloc_id++;
396                                         n_obj++;
397
398                                         printf("Object %d, %s is a ",newObj,full_name);
399
400                                         /* We're going to create an object for it */
401                                         if((equivalentObj = find_obj_in_list(stats.st_dev, stats.st_ino)) > 0)
402                                         {
403                                                 /* we need to make a hard link */
404                                                 printf("hard link to object %d\n",equivalentObj);
405                                                 error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_HARDLINK, &stats, parent, entry->d_name, equivalentObj, NULL);
406                                         }
407                                         else
408                                         {
409
410                                                 add_obj_to_list(stats.st_dev,stats.st_ino,newObj);
411
412                                                 if(S_ISLNK(stats.st_mode))
413                                                 {
414
415                                                         char symname[500];
416                                                         int ret;
417
418                                                         memset(symname,0, sizeof(symname));
419
420                                                         ret = readlink(full_name,symname,sizeof(symname) -1);
421
422                                                         if (ret < 0)
423                                                                 perror("readlink of symlink");
424
425                                                         printf("symlink to \"%s\"\n",symname);
426                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_SYMLINK, &stats, parent, entry->d_name, -1, symname);
427
428                                                 }
429                                                 else if(S_ISREG(stats.st_mode))
430                                                 {
431                                                         printf("file, ");
432                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_FILE, &stats, parent, entry->d_name, -1, NULL);
433
434                                                         if(error >= 0)
435                                                         {
436                                                                 int h;
437                                                                 u8 bytes[512];
438                                                                 int n_bytes;
439                                                                 int chunk = 0;
440
441                                                                 h = open(full_name,O_RDONLY);
442                                                                 if(h >= 0)
443                                                                 {
444                                                                         memset(bytes,0xff,512);
445                                                                         while((n_bytes = read(h,bytes,512)) > 0)
446                                                                         {
447                                                                                 chunk++;
448                                                                                 write_chunk(bytes,newObj,chunk,n_bytes);
449                                                                                 memset(bytes,0xff,512);
450                                                                         }
451                                                                         if(n_bytes < 0)
452                                                                            error = n_bytes;
453
454                                                                         printf("%d data chunks written\n",chunk);
455                                                                 }
456                                                                 else
457                                                                 {
458                                                                         perror("Error opening file");
459                                                                 }
460                                                                 close(h);
461
462                                                         }
463
464                                                 }
465                                                 else if(S_ISSOCK(stats.st_mode))
466                                                 {
467                                                         printf("socket\n");
468                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL);
469                                                 }
470                                                 else if(S_ISFIFO(stats.st_mode))
471                                                 {
472                                                         printf("fifo\n");
473                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL);
474                                                 }
475                                                 else if(S_ISCHR(stats.st_mode))
476                                                 {
477                                                         printf("character device\n");
478                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL);
479                                                 }
480                                                 else if(S_ISBLK(stats.st_mode))
481                                                 {
482                                                         printf("block device\n");
483                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_SPECIAL, &stats, parent, entry->d_name, -1, NULL);
484                                                 }
485                                                 else if(S_ISDIR(stats.st_mode))
486                                                 {
487                                                         printf("directory\n");
488                                                         error =  write_object_header(newObj, YAFFS_OBJECT_TYPE_DIRECTORY, &stats, parent, entry->d_name, -1, NULL);
489 // NCB modified 10/9/2001                               process_directory(1,full_name);
490                                                         process_directory(newObj,full_name);
491                                                 }
492                                         }
493                                 }
494                                 else
495                                 {
496                                         printf(" we don't handle this type\n");
497                                 }
498                         }
499                 }
500         }
501
502         return 0;
503
504 }
505
506
507 int main(int argc, char *argv[])
508 {
509         struct stat stats;
510
511         printf("mkyaffsimage: image building tool for YAFFS built "__DATE__"\n");
512
513         if(argc < 3)
514         {
515                 printf("usage: mkyaffsimage dir image_file [convert]\n");
516                 printf("           dir        the directory tree to be converted\n");
517                 printf("           image_file the output file to hold the image\n");
518         printf("           'convert'  produce a big-endian image from a little-endian machine\n");
519                 exit(1);
520         }
521
522     if ((argc == 4) && (!strncmp(argv[3], "convert", strlen("convert"))))
523     {
524         convert_endian = 1;
525     }
526
527         if(stat(argv[1],&stats) < 0)
528         {
529                 printf("Could not stat %s\n",argv[1]);
530                 exit(1);
531         }
532
533         if(!S_ISDIR(stats.st_mode))
534         {
535                 printf(" %s is not a directory\n",argv[1]);
536                 exit(1);
537         }
538
539         outFile = open(argv[2],O_CREAT | O_TRUNC | O_WRONLY, S_IREAD | S_IWRITE);
540
541
542         if(outFile < 0)
543         {
544                 printf("Could not open output file %s\n",argv[2]);
545                 exit(1);
546         }
547
548         printf("Processing directory %s into image file %s\n",argv[1],argv[2]);
549         error =  write_object_header(1, YAFFS_OBJECT_TYPE_DIRECTORY, &stats, 1,"", -1, NULL);
550         if(error)
551         error = process_directory(YAFFS_OBJECTID_ROOT,argv[1]);
552
553         close(outFile);
554
555         if(error < 0)
556         {
557                 perror("operation incomplete");
558                 exit(1);
559         }
560         else
561         {
562                 printf("Operation complete.\n"
563                        "%d objects in %d directories\n"
564                        "%d NAND pages\n",n_obj, nDirectories, nPages);
565         }
566
567         close(outFile);
568
569         exit(0);
570 }
571