Whamcloud - gitweb
Merge branch 'maint' into next
[tools/e2fsprogs.git] / e2fsck / util.c
1 /*
2  * util.c --- miscellaneous utilities
3  *
4  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
5  *
6  * %Begin-Header%
7  * This file may be redistributed under the terms of the GNU Public
8  * License.
9  * %End-Header%
10  */
11
12 #include "config.h"
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <unistd.h>
16 #include <string.h>
17 #include <ctype.h>
18 #ifdef __linux__
19 #include <sys/utsname.h>
20 #endif
21
22 #ifdef HAVE_CONIO_H
23 #undef HAVE_TERMIOS_H
24 #include <conio.h>
25 #define read_a_char()   getch()
26 #else
27 #ifdef HAVE_TERMIOS_H
28 #include <termios.h>
29 #endif
30 #endif
31
32 #ifdef HAVE_MALLOC_H
33 #include <malloc.h>
34 #endif
35
36 #ifdef HAVE_ERRNO_H
37 #include <errno.h>
38 #endif
39
40 #include "e2fsck.h"
41
42 extern e2fsck_t e2fsck_global_ctx;   /* Try your very best not to use this! */
43
44 #include <stdarg.h>
45 #include <time.h>
46 #include <sys/time.h>
47 #include <sys/resource.h>
48
49 void fatal_error(e2fsck_t ctx, const char *msg)
50 {
51         ext2_filsys fs = ctx->fs;
52         int exit_value = FSCK_ERROR;
53
54         if (msg)
55                 fprintf (stderr, "e2fsck: %s\n", msg);
56         if (!fs)
57                 goto out;
58         if (fs->io && fs->super) {
59                 ext2fs_mmp_stop(ctx->fs);
60                 if (ctx->fs->io->magic == EXT2_ET_MAGIC_IO_CHANNEL)
61                         io_channel_flush(ctx->fs->io);
62                 else
63                         log_err(ctx, "e2fsck: io manager magic bad!\n");
64         }
65         if (ext2fs_test_changed(fs)) {
66                 exit_value |= FSCK_NONDESTRUCT;
67                 log_out(ctx, _("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n"),
68                         ctx->device_name);
69                 if (ctx->mount_flags & EXT2_MF_ISROOT)
70                         exit_value |= FSCK_REBOOT;
71         }
72         if (!ext2fs_test_valid(fs)) {
73                 log_out(ctx, _("\n%s: ********** WARNING: Filesystem still has "
74                                "errors **********\n\n"), ctx->device_name);
75                 exit_value |= FSCK_UNCORRECTED;
76                 exit_value &= ~FSCK_NONDESTRUCT;
77         }
78 out:
79         ctx->flags |= E2F_FLAG_ABORT;
80         if (ctx->flags & E2F_FLAG_SETJMP_OK)
81                 longjmp(ctx->abort_loc, 1);
82         exit(exit_value);
83 }
84
85 void log_out(e2fsck_t ctx, const char *fmt, ...)
86 {
87         va_list pvar;
88
89         va_start(pvar, fmt);
90         vprintf(fmt, pvar);
91         va_end(pvar);
92         if (ctx->logf) {
93                 va_start(pvar, fmt);
94                 vfprintf(ctx->logf, fmt, pvar);
95                 va_end(pvar);
96         }
97 }
98
99 void log_err(e2fsck_t ctx, const char *fmt, ...)
100 {
101         va_list pvar;
102
103         va_start(pvar, fmt);
104         vfprintf(stderr, fmt, pvar);
105         va_end(pvar);
106         if (ctx->logf) {
107                 va_start(pvar, fmt);
108                 vfprintf(ctx->logf, fmt, pvar);
109                 va_end(pvar);
110         }
111 }
112
113 void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned int size,
114                              const char *description)
115 {
116         void *ret;
117         char buf[256];
118
119 #ifdef DEBUG_ALLOCATE_MEMORY
120         printf("Allocating %u bytes for %s...\n", size, description);
121 #endif
122         ret = malloc(size);
123         if (!ret) {
124                 sprintf(buf, "Can't allocate %u bytes for %s\n",
125                         size, description);
126                 fatal_error(ctx, buf);
127         }
128         memset(ret, 0, size);
129         return ret;
130 }
131
132 char *string_copy(e2fsck_t ctx EXT2FS_ATTR((unused)),
133                   const char *str, int len)
134 {
135         char    *ret;
136
137         if (!str)
138                 return NULL;
139         if (!len)
140                 len = strlen(str);
141         ret = malloc(len+1);
142         if (ret) {
143                 strncpy(ret, str, len);
144                 ret[len] = 0;
145         }
146         return ret;
147 }
148
149 #ifndef HAVE_STRNLEN
150 /*
151  * Incredibly, libc5 doesn't appear to have strnlen.  So we have to
152  * provide our own.
153  */
154 int e2fsck_strnlen(const char * s, int count)
155 {
156         const char *cp = s;
157
158         while (count-- && *cp)
159                 cp++;
160         return cp - s;
161 }
162 #endif
163
164 #ifndef HAVE_CONIO_H
165 static int read_a_char(void)
166 {
167         char    c;
168         int     r;
169         int     fail = 0;
170
171         while(1) {
172                 if (e2fsck_global_ctx &&
173                     (e2fsck_global_ctx->flags & E2F_FLAG_CANCEL)) {
174                         return 3;
175                 }
176                 r = read(0, &c, 1);
177                 if (r == 1)
178                         return c;
179                 if (fail++ > 100)
180                         break;
181         }
182         return EOF;
183 }
184 #endif
185
186 int ask_yn(e2fsck_t ctx, const char * string, int def)
187 {
188         int             c;
189         const char      *defstr;
190         const char      *short_yes = _("yY");
191         const char      *short_no = _("nN");
192
193 #ifdef HAVE_TERMIOS_H
194         struct termios  termios, tmp;
195
196         tcgetattr (0, &termios);
197         tmp = termios;
198         tmp.c_lflag &= ~(ICANON | ECHO);
199         tmp.c_cc[VMIN] = 1;
200         tmp.c_cc[VTIME] = 0;
201         tcsetattr (0, TCSANOW, &tmp);
202 #endif
203
204         if (def == 1)
205                 defstr = _(_("<y>"));
206         else if (def == 0)
207                 defstr = _(_("<n>"));
208         else
209                 defstr = _(" (y/n)");
210         log_out(ctx, "%s%s? ", string, defstr);
211         while (1) {
212                 fflush (stdout);
213                 if ((c = read_a_char()) == EOF)
214                         break;
215                 if (c == 3) {
216 #ifdef HAVE_TERMIOS_H
217                         tcsetattr (0, TCSANOW, &termios);
218 #endif
219                         if (ctx->flags & E2F_FLAG_SETJMP_OK) {
220                                 log_out(ctx, "\n");
221                                 longjmp(e2fsck_global_ctx->abort_loc, 1);
222                         }
223                         log_out(ctx, "%s", _("cancelled!\n"));
224                         return 0;
225                 }
226                 if (strchr(short_yes, (char) c)) {
227                         def = 1;
228                         break;
229                 }
230                 else if (strchr(short_no, (char) c)) {
231                         def = 0;
232                         break;
233                 }
234                 else if ((c == 27 || c == ' ' || c == '\n') && (def != -1))
235                         break;
236         }
237         if (def)
238                 log_out(ctx, "%s", _("yes\n"));
239         else
240                 log_out(ctx, "%s", _("no\n"));
241 #ifdef HAVE_TERMIOS_H
242         tcsetattr (0, TCSANOW, &termios);
243 #endif
244         return def;
245 }
246
247 int ask (e2fsck_t ctx, const char * string, int def)
248 {
249         if (ctx->options & E2F_OPT_NO) {
250                 log_out(ctx, _("%s? no\n\n"), string);
251                 return 0;
252         }
253         if (ctx->options & E2F_OPT_YES) {
254                 log_out(ctx, _("%s? yes\n\n"), string);
255                 return 1;
256         }
257         if (ctx->options & E2F_OPT_PREEN) {
258                 log_out(ctx, "%s? %s\n\n", string, def ? _("yes") : _("no"));
259                 return def;
260         }
261         return ask_yn(ctx, string, def);
262 }
263
264 void e2fsck_read_bitmaps(e2fsck_t ctx)
265 {
266         ext2_filsys fs = ctx->fs;
267         errcode_t       retval;
268         const char      *old_op;
269         unsigned int    save_type;
270
271         if (ctx->invalid_bitmaps) {
272                 com_err(ctx->program_name, 0,
273                     _("e2fsck_read_bitmaps: illegal bitmap block(s) for %s"),
274                         ctx->device_name);
275                 fatal_error(ctx, 0);
276         }
277
278         old_op = ehandler_operation(_("reading inode and block bitmaps"));
279         e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, "fs_bitmaps",
280                                &save_type);
281         ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
282         retval = ext2fs_read_bitmaps(fs);
283         ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
284         fs->default_bitmap_type = save_type;
285         ehandler_operation(old_op);
286         if (retval) {
287                 com_err(ctx->program_name, retval,
288                         _("while retrying to read bitmaps for %s"),
289                         ctx->device_name);
290                 fatal_error(ctx, 0);
291         }
292 }
293
294 void e2fsck_write_bitmaps(e2fsck_t ctx)
295 {
296         ext2_filsys fs = ctx->fs;
297         errcode_t       retval;
298         const char      *old_op;
299
300         old_op = ehandler_operation(_("writing block and inode bitmaps"));
301         retval = ext2fs_write_bitmaps(fs);
302         ehandler_operation(old_op);
303         if (retval) {
304                 com_err(ctx->program_name, retval,
305                         _("while rewriting block and inode bitmaps for %s"),
306                         ctx->device_name);
307                 fatal_error(ctx, 0);
308         }
309 }
310
311 void preenhalt(e2fsck_t ctx)
312 {
313         ext2_filsys fs = ctx->fs;
314
315         if (!(ctx->options & E2F_OPT_PREEN))
316                 return;
317         log_err(ctx, _("\n\n%s: UNEXPECTED INCONSISTENCY; "
318                 "RUN fsck MANUALLY.\n\t(i.e., without -a or -p options)\n"),
319                ctx->device_name);
320         ctx->flags |= E2F_FLAG_EXITING;
321         if (fs != NULL) {
322                 fs->super->s_state |= EXT2_ERROR_FS;
323                 ext2fs_mark_super_dirty(fs);
324                 ext2fs_close(fs);
325         }
326         exit(FSCK_UNCORRECTED);
327 }
328
329 #ifdef RESOURCE_TRACK
330 void init_resource_track(struct resource_track *track, io_channel channel)
331 {
332 #ifdef HAVE_GETRUSAGE
333         struct rusage r;
334 #endif
335         io_stats io_start = 0;
336
337         track->brk_start = sbrk(0);
338         gettimeofday(&track->time_start, 0);
339 #ifdef HAVE_GETRUSAGE
340 #ifdef sun
341         memset(&r, 0, sizeof(struct rusage));
342 #endif
343         getrusage(RUSAGE_SELF, &r);
344         track->user_start = r.ru_utime;
345         track->system_start = r.ru_stime;
346 #else
347         track->user_start.tv_sec = track->user_start.tv_usec = 0;
348         track->system_start.tv_sec = track->system_start.tv_usec = 0;
349 #endif
350         track->bytes_read = 0;
351         track->bytes_written = 0;
352         if (channel && channel->manager && channel->manager->get_stats)
353                 channel->manager->get_stats(channel, &io_start);
354         if (io_start) {
355                 track->bytes_read = io_start->bytes_read;
356                 track->bytes_written = io_start->bytes_written;
357         }
358 }
359
360 #ifdef __GNUC__
361 #define _INLINE_ __inline__
362 #else
363 #define _INLINE_
364 #endif
365
366 static _INLINE_ float timeval_subtract(struct timeval *tv1,
367                                        struct timeval *tv2)
368 {
369         return ((tv1->tv_sec - tv2->tv_sec) +
370                 ((float) (tv1->tv_usec - tv2->tv_usec)) / 1000000);
371 }
372
373 void print_resource_track(e2fsck_t ctx, const char *desc,
374                           struct resource_track *track, io_channel channel)
375 {
376 #ifdef HAVE_GETRUSAGE
377         struct rusage r;
378 #endif
379 #ifdef HAVE_MALLINFO
380         struct mallinfo malloc_info;
381 #endif
382         struct timeval time_end;
383
384         if ((desc && !(ctx->options & E2F_OPT_TIME2)) ||
385             (!desc && !(ctx->options & E2F_OPT_TIME)))
386                 return;
387
388         e2fsck_clear_progbar(ctx);
389         gettimeofday(&time_end, 0);
390
391         if (desc)
392                 log_out(ctx, "%s: ", desc);
393
394 #ifdef HAVE_MALLINFO
395 #define kbytes(x)       (((unsigned long)(x) + 1023) / 1024)
396
397         malloc_info = mallinfo();
398         log_out(ctx, _("Memory used: %luk/%luk (%luk/%luk), "),
399                 kbytes(malloc_info.arena), kbytes(malloc_info.hblkhd),
400                 kbytes(malloc_info.uordblks), kbytes(malloc_info.fordblks));
401 #else
402         log_out(ctx, _("Memory used: %lu, "),
403                 (unsigned long) (((char *) sbrk(0)) -
404                                  ((char *) track->brk_start)));
405 #endif
406 #ifdef HAVE_GETRUSAGE
407         getrusage(RUSAGE_SELF, &r);
408
409         log_out(ctx, _("time: %5.2f/%5.2f/%5.2f\n"),
410                 timeval_subtract(&time_end, &track->time_start),
411                 timeval_subtract(&r.ru_utime, &track->user_start),
412                 timeval_subtract(&r.ru_stime, &track->system_start));
413 #else
414         log_out(ctx, _("elapsed time: %6.3f\n"),
415                 timeval_subtract(&time_end, &track->time_start));
416 #endif
417 #define mbytes(x)       (((x) + 1048575) / 1048576)
418         if (channel && channel->manager && channel->manager->get_stats) {
419                 io_stats delta = 0;
420                 unsigned long long bytes_read = 0;
421                 unsigned long long bytes_written = 0;
422
423                 if (desc)
424                         log_out(ctx, "%s: ", desc);
425
426                 channel->manager->get_stats(channel, &delta);
427                 if (delta) {
428                         bytes_read = delta->bytes_read - track->bytes_read;
429                         bytes_written = delta->bytes_written -
430                                 track->bytes_written;
431                 }
432                 log_out(ctx, "I/O read: %lluMB, write: %lluMB, "
433                         "rate: %.2fMB/s\n",
434                         mbytes(bytes_read), mbytes(bytes_written),
435                         (double)mbytes(bytes_read + bytes_written) /
436                         timeval_subtract(&time_end, &track->time_start));
437         }
438 }
439 #endif /* RESOURCE_TRACK */
440
441 void e2fsck_read_inode(e2fsck_t ctx, unsigned long ino,
442                               struct ext2_inode * inode, const char *proc)
443 {
444         errcode_t retval;
445
446         retval = ext2fs_read_inode(ctx->fs, ino, inode);
447         if (retval) {
448                 com_err("ext2fs_read_inode", retval,
449                         _("while reading inode %lu in %s"), ino, proc);
450                 fatal_error(ctx, 0);
451         }
452 }
453
454 void e2fsck_read_inode_full(e2fsck_t ctx, unsigned long ino,
455                             struct ext2_inode *inode, int bufsize,
456                             const char *proc)
457 {
458         errcode_t retval;
459
460         retval = ext2fs_read_inode_full(ctx->fs, ino, inode, bufsize);
461         if (retval) {
462                 com_err("ext2fs_read_inode_full", retval,
463                         _("while reading inode %lu in %s"), ino, proc);
464                 fatal_error(ctx, 0);
465         }
466 }
467
468 void e2fsck_write_inode_full(e2fsck_t ctx, unsigned long ino,
469                              struct ext2_inode * inode, int bufsize,
470                              const char *proc)
471 {
472         errcode_t retval;
473
474         retval = ext2fs_write_inode_full(ctx->fs, ino, inode, bufsize);
475         if (retval) {
476                 com_err("ext2fs_write_inode", retval,
477                         _("while writing inode %lu in %s"), ino, proc);
478                 fatal_error(ctx, 0);
479         }
480 }
481
482 void e2fsck_write_inode(e2fsck_t ctx, unsigned long ino,
483                         struct ext2_inode * inode, const char *proc)
484 {
485         errcode_t retval;
486
487         retval = ext2fs_write_inode(ctx->fs, ino, inode);
488         if (retval) {
489                 com_err("ext2fs_write_inode", retval,
490                         _("while writing inode %lu in %s"), ino, proc);
491                 fatal_error(ctx, 0);
492         }
493 }
494
495 #ifdef MTRACE
496 void mtrace_print(char *mesg)
497 {
498         FILE    *malloc_get_mallstream();
499         FILE    *f = malloc_get_mallstream();
500
501         if (f)
502                 fprintf(f, "============= %s\n", mesg);
503 }
504 #endif
505
506 blk64_t get_backup_sb(e2fsck_t ctx, ext2_filsys fs, const char *name,
507                       io_manager manager)
508 {
509         struct ext2_super_block *sb;
510         io_channel              io = NULL;
511         void                    *buf = NULL;
512         int                     blocksize;
513         blk64_t                 superblock, ret_sb = 8193;
514
515         if (fs && fs->super) {
516                 ret_sb = (fs->super->s_blocks_per_group +
517                           fs->super->s_first_data_block);
518                 if (ctx) {
519                         ctx->superblock = ret_sb;
520                         ctx->blocksize = fs->blocksize;
521                 }
522                 return ret_sb;
523         }
524
525         if (ctx) {
526                 if (ctx->blocksize) {
527                         ret_sb = ctx->blocksize * 8;
528                         if (ctx->blocksize == 1024)
529                                 ret_sb++;
530                         ctx->superblock = ret_sb;
531                         return ret_sb;
532                 }
533                 ctx->superblock = ret_sb;
534                 ctx->blocksize = 1024;
535         }
536
537         if (!name || !manager)
538                 goto cleanup;
539
540         if (manager->open(name, 0, &io) != 0)
541                 goto cleanup;
542
543         if (ext2fs_get_mem(SUPERBLOCK_SIZE, &buf))
544                 goto cleanup;
545         sb = (struct ext2_super_block *) buf;
546
547         for (blocksize = EXT2_MIN_BLOCK_SIZE;
548              blocksize <= EXT2_MAX_BLOCK_SIZE ; blocksize *= 2) {
549                 superblock = blocksize*8;
550                 if (blocksize == 1024)
551                         superblock++;
552                 io_channel_set_blksize(io, blocksize);
553                 if (io_channel_read_blk64(io, superblock,
554                                         -SUPERBLOCK_SIZE, buf))
555                         continue;
556 #ifdef WORDS_BIGENDIAN
557                 if (sb->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC))
558                         ext2fs_swap_super(sb);
559 #endif
560                 if ((sb->s_magic == EXT2_SUPER_MAGIC) &&
561                     (EXT2_BLOCK_SIZE(sb) == blocksize)) {
562                         ret_sb = superblock;
563                         if (ctx) {
564                                 ctx->superblock = superblock;
565                                 ctx->blocksize = blocksize;
566                         }
567                         break;
568                 }
569         }
570
571 cleanup:
572         if (io)
573                 io_channel_close(io);
574         if (buf)
575                 ext2fs_free_mem(&buf);
576         return (ret_sb);
577 }
578
579 /*
580  * Given a mode, return the ext2 file type
581  */
582 int ext2_file_type(unsigned int mode)
583 {
584         if (LINUX_S_ISREG(mode))
585                 return EXT2_FT_REG_FILE;
586
587         if (LINUX_S_ISDIR(mode))
588                 return EXT2_FT_DIR;
589
590         if (LINUX_S_ISCHR(mode))
591                 return EXT2_FT_CHRDEV;
592
593         if (LINUX_S_ISBLK(mode))
594                 return EXT2_FT_BLKDEV;
595
596         if (LINUX_S_ISLNK(mode))
597                 return EXT2_FT_SYMLINK;
598
599         if (LINUX_S_ISFIFO(mode))
600                 return EXT2_FT_FIFO;
601
602         if (LINUX_S_ISSOCK(mode))
603                 return EXT2_FT_SOCK;
604
605         return 0;
606 }
607
608 #define STRIDE_LENGTH 8
609 /*
610  * Helper function which zeros out _num_ blocks starting at _blk_.  In
611  * case of an error, the details of the error is returned via _ret_blk_
612  * and _ret_count_ if they are non-NULL pointers.  Returns 0 on
613  * success, and an error code on an error.
614  *
615  * As a special case, if the first argument is NULL, then it will
616  * attempt to free the static zeroizing buffer.  (This is to keep
617  * programs that check for memory leaks happy.)
618  */
619 errcode_t e2fsck_zero_blocks(ext2_filsys fs, blk_t blk, int num,
620                              blk_t *ret_blk, int *ret_count)
621 {
622         int             j, count;
623         static char     *buf;
624         errcode_t       retval;
625
626         /* If fs is null, clean up the static buffer and return */
627         if (!fs) {
628                 if (buf) {
629                         free(buf);
630                         buf = 0;
631                 }
632                 return 0;
633         }
634         /* Allocate the zeroizing buffer if necessary */
635         if (!buf) {
636                 buf = malloc(fs->blocksize * STRIDE_LENGTH);
637                 if (!buf) {
638                         com_err("malloc", ENOMEM, "%s",
639                                 _("while allocating zeroizing buffer"));
640                         exit(1);
641                 }
642                 memset(buf, 0, fs->blocksize * STRIDE_LENGTH);
643         }
644         /* OK, do the write loop */
645         for (j = 0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH) {
646                 count = num - j;
647                 if (count > STRIDE_LENGTH)
648                         count = STRIDE_LENGTH;
649                 retval = io_channel_write_blk64(fs->io, blk, count, buf);
650                 if (retval) {
651                         if (ret_count)
652                                 *ret_count = count;
653                         if (ret_blk)
654                                 *ret_blk = blk;
655                         return retval;
656                 }
657         }
658         return 0;
659 }
660
661 /*
662  * Check to see if a filesystem is in /proc/filesystems.
663  * Returns 1 if found, 0 if not
664  */
665 int fs_proc_check(const char *fs_name)
666 {
667         FILE    *f;
668         char    buf[80], *cp, *t;
669
670         f = fopen("/proc/filesystems", "r");
671         if (!f)
672                 return (0);
673         while (!feof(f)) {
674                 if (!fgets(buf, sizeof(buf), f))
675                         break;
676                 cp = buf;
677                 if (!isspace(*cp)) {
678                         while (*cp && !isspace(*cp))
679                                 cp++;
680                 }
681                 while (*cp && isspace(*cp))
682                         cp++;
683                 if ((t = strchr(cp, '\n')) != NULL)
684                         *t = 0;
685                 if ((t = strchr(cp, '\t')) != NULL)
686                         *t = 0;
687                 if ((t = strchr(cp, ' ')) != NULL)
688                         *t = 0;
689                 if (!strcmp(fs_name, cp)) {
690                         fclose(f);
691                         return (1);
692                 }
693         }
694         fclose(f);
695         return (0);
696 }
697
698 /*
699  * Check to see if a filesystem is available as a module
700  * Returns 1 if found, 0 if not
701  */
702 int check_for_modules(const char *fs_name)
703 {
704 #ifdef __linux__
705         struct utsname  uts;
706         FILE            *f;
707         char            buf[1024], *cp, *t;
708         int             i;
709
710         if (uname(&uts))
711                 return (0);
712         snprintf(buf, sizeof(buf), "/lib/modules/%s/modules.dep", uts.release);
713
714         f = fopen(buf, "r");
715         if (!f)
716                 return (0);
717         while (!feof(f)) {
718                 if (!fgets(buf, sizeof(buf), f))
719                         break;
720                 if ((cp = strchr(buf, ':')) != NULL)
721                         *cp = 0;
722                 else
723                         continue;
724                 if ((cp = strrchr(buf, '/')) != NULL)
725                         cp++;
726                 else
727                         cp = buf;
728                 i = strlen(cp);
729                 if (i > 3) {
730                         t = cp + i - 3;
731                         if (!strcmp(t, ".ko"))
732                                 *t = 0;
733                 }
734                 if (!strcmp(cp, fs_name)) {
735                         fclose(f);
736                         return (1);
737                 }
738         }
739         fclose(f);
740 #endif /* __linux__ */
741         return (0);
742 }
743
744 /*
745  * Helper function that does the right thing if write returns a
746  * partial write, or an EGAIN/EINTR error.
747  */
748 int write_all(int fd, char *buf, size_t count)
749 {
750         ssize_t ret;
751         int c = 0;
752
753         while (count > 0) {
754                 ret = write(fd, buf, count);
755                 if (ret < 0) {
756                         if ((errno == EAGAIN) || (errno == EINTR))
757                                 continue;
758                         return -1;
759                 }
760                 count -= ret;
761                 buf += ret;
762                 c += ret;
763         }
764         return c;
765 }
766
767 void dump_mmp_msg(struct mmp_struct *mmp, const char *msg)
768 {
769
770         if (msg)
771                 printf("MMP check failed: %s\n", msg);
772         if (mmp) {
773                 time_t t = mmp->mmp_time;
774
775                 printf("MMP error info: last update: %s node: %s device: %s\n",
776                        ctime(&t), mmp->mmp_nodename, mmp->mmp_bdevname);
777         }
778 }
779
780 errcode_t e2fsck_mmp_update(ext2_filsys fs)
781 {
782         errcode_t retval;
783
784         retval = ext2fs_mmp_update(fs);
785         if (retval == EXT2_ET_MMP_CHANGE_ABORT)
786                 dump_mmp_msg(fs->mmp_cmp,
787                              _("UNEXPECTED INCONSISTENCY: the filesystem is "
788                                "being modified while fsck is running.\n"));
789
790         return retval;
791 }
792
793 void e2fsck_set_bitmap_type(ext2_filsys fs, unsigned int default_type,
794                             const char *profile_name, unsigned int *old_type)
795 {
796         unsigned type;
797
798         if (old_type)
799                 *old_type = fs->default_bitmap_type;
800         profile_get_uint(e2fsck_global_ctx->profile, "bitmaps",
801                          profile_name, 0, default_type, &type);
802         profile_get_uint(e2fsck_global_ctx->profile, "bitmaps",
803                          "all", 0, type, &type);
804         fs->default_bitmap_type = type ? type : default_type;
805 }
806
807 errcode_t e2fsck_allocate_inode_bitmap(ext2_filsys fs, const char *descr,
808                                        int deftype,
809                                        const char *name,
810                                        ext2fs_inode_bitmap *ret)
811 {
812         errcode_t       retval;
813         unsigned int    save_type;
814
815         e2fsck_set_bitmap_type(fs, deftype, name, &save_type);
816         retval = ext2fs_allocate_inode_bitmap(fs, descr, ret);
817         fs->default_bitmap_type = save_type;
818         return retval;
819 }
820
821 errcode_t e2fsck_allocate_block_bitmap(ext2_filsys fs, const char *descr,
822                                        int deftype,
823                                        const char *name,
824                                        ext2fs_block_bitmap *ret)
825 {
826         errcode_t       retval;
827         unsigned int    save_type;
828
829         e2fsck_set_bitmap_type(fs, deftype, name, &save_type);
830         retval = ext2fs_allocate_block_bitmap(fs, descr, ret);
831         fs->default_bitmap_type = save_type;
832         return retval;
833 }
834
835 errcode_t e2fsck_allocate_subcluster_bitmap(ext2_filsys fs, const char *descr,
836                                             int deftype,
837                                             const char *name,
838                                             ext2fs_block_bitmap *ret)
839 {
840         errcode_t       retval;
841         unsigned int    save_type;
842
843         e2fsck_set_bitmap_type(fs, deftype, name, &save_type);
844         retval = ext2fs_allocate_subcluster_bitmap(fs, descr, ret);
845         fs->default_bitmap_type = save_type;
846         return retval;
847 }