← Back to branch summary

~ubuntu-branches/debian/jessie/ufsutils/jessie

« back to all changes in this revision

Viewing changes to sbin/fsck_ffs/main.c

  • Committer: Package Import Robot
  • Author(s): Robert Millan
  • Date: 2014-05-22 18:05:36 UTC
  • mfrom: (11.1.3 experimental)
  • Revision ID: package-import@ubuntu.com-20140522180536-nsmuhw6ryv9awr88
Tags: 10.0-3
http://bugs.debian.org/741088
Fix FTBFS due to missing <libutil.h> by adding a libutil-freebsd-dev
build-dep (Closes: #741088). Thanks Cyril Brulebois.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sbin/fsck_ffs/main.c
82
82
        sync();
83
83
        skipclean = 1;
84
84
        inoopt = 0;
85
 
        while ((ch = getopt(argc, argv, "ab:Bc:CdEfFm:npryZ")) != -1) {
 
85
        while ((ch = getopt(argc, argv, "b:Bc:CdEfFm:nprSyZa")) != -1) {
86
86
                switch (ch) {
87
87
                case 'b':
88
88
                        skipclean = 0;
144
144
                        inoopt++;
145
145
                        break;
146
146
 
 
147
                case 'S':
 
148
                        surrender = 1;
 
149
                        break;
 
150
 
147
151
                case 'y':
148
152
                        yflag++;
149
153
                        nflag = 0;
216
220
        struct statfs *mntp;
217
221
        struct stat snapdir;
218
222
        struct group *grp;
219
 
        ufs2_daddr_t blks;
220
223
        struct iovec *iov;
221
224
        char errmsg[255];
222
225
        int iovlen;
223
226
        int cylno;
224
 
        ino_t files;
 
227
        intmax_t blks, files;
225
228
        size_t size;
226
229
 
227
230
        iov = NULL;
250
253
        sblock_init();
251
254
        if (bkgrdcheck) {
252
255
                if ((fsreadfd = open(filesys, O_RDONLY)) < 0 || readsb(0) == 0)
253
 
                        exit(3);        /* Cannot read superblock */
 
256
                        exit(8);        /* Cannot read superblock */
254
257
                close(fsreadfd);
255
258
                /* Earlier background failed or journaled */
256
259
                if (sblock.fs_flags & (FS_NEEDSFSCK | FS_SUJ))
270
273
                 * If file system is gjournaled, check it here.
271
274
                 */
272
275
                if ((fsreadfd = open(filesys, O_RDONLY)) < 0 || readsb(0) == 0)
273
 
                        exit(3);        /* Cannot read superblock */
 
276
                        exit(8);        /* Cannot read superblock */
274
277
                close(fsreadfd);
275
278
                if ((sblock.fs_flags & FS_GJOURNAL) != 0) {
276
279
                        //printf("GJournaled file system detected on %s.\n",
285
288
                                        exit(0);
286
289
                                exit(4);
287
290
                        } else {
288
 
                                pfatal("UNEXPECTED INCONSISTENCY, %s\n",
289
 
                                    "CANNOT RUN FAST FSCK\n");
 
291
                                pfatal(
 
292
                            "UNEXPECTED INCONSISTENCY, CANNOT RUN FAST FSCK\n");
290
293
                        }
291
294
                }
292
295
        }
303
306
                        pfatal("NOT MOUNTED, CANNOT RUN IN BACKGROUND\n");
304
307
                } else if ((mntp->f_flags & MNT_SOFTDEP) == 0) {
305
308
                        bkgrdflag = 0;
306
 
                        pfatal("NOT USING SOFT UPDATES, %s\n",
307
 
                            "CANNOT RUN IN BACKGROUND");
 
309
                        pfatal(
 
310
                          "NOT USING SOFT UPDATES, CANNOT RUN IN BACKGROUND\n");
308
311
                } else if ((mntp->f_flags & MNT_RDONLY) != 0) {
309
312
                        bkgrdflag = 0;
310
313
                        pfatal("MOUNTED READ-ONLY, CANNOT RUN IN BACKGROUND\n");
312
315
                        if (readsb(0) != 0) {
313
316
                                if (sblock.fs_flags & (FS_NEEDSFSCK | FS_SUJ)) {
314
317
                                        bkgrdflag = 0;
315
 
                                        pfatal("UNEXPECTED INCONSISTENCY, %s\n",
316
 
                                            "CANNOT RUN IN BACKGROUND\n");
 
318
                                        pfatal(
 
319
                        "UNEXPECTED INCONSISTENCY, CANNOT RUN IN BACKGROUND\n");
317
320
                                }
318
321
                                if ((sblock.fs_flags & FS_UNCLEAN) == 0 &&
319
322
                                    skipclean && ckclean) {
321
324
                                         * file system is clean;
322
325
                                         * skip snapshot and report it clean
323
326
                                         */
324
 
                                        pwarn("FILE SYSTEM CLEAN; %s\n",
325
 
                                            "SKIPPING CHECKS");
 
327
                                        pwarn(
 
328
                                        "FILE SYSTEM CLEAN; SKIPPING CHECKS\n");
326
329
                                        goto clean;
327
330
                                }
328
331
                        }
334
337
                        if (stat(snapname, &snapdir) < 0) {
335
338
                                if (errno != ENOENT) {
336
339
                                        bkgrdflag = 0;
337
 
                                        pfatal("CANNOT FIND %s %s: %s, %s\n",
338
 
                                            "SNAPSHOT DIRECTORY",
339
 
                                            snapname, strerror(errno),
340
 
                                            "CANNOT RUN IN BACKGROUND");
 
340
                                        pfatal(
 
341
        "CANNOT FIND SNAPSHOT DIRECTORY %s: %s, CANNOT RUN IN BACKGROUND\n",
 
342
                                            snapname, strerror(errno));
341
343
                                } else if ((grp = getgrnam("operator")) == 0 ||
342
344
                                    mkdir(snapname, 0770) < 0 ||
343
345
                                    chown(snapname, -1, grp->gr_gid) < 0 ||
344
346
                                    chmod(snapname, 0770) < 0) {
345
347
                                        bkgrdflag = 0;
346
 
                                        pfatal("CANNOT CREATE %s %s: %s, %s\n",
347
 
                                            "SNAPSHOT DIRECTORY",
348
 
                                            snapname, strerror(errno),
349
 
                                            "CANNOT RUN IN BACKGROUND");
 
348
                                        pfatal(
 
349
        "CANNOT CREATE SNAPSHOT DIRECTORY %s: %s, CANNOT RUN IN BACKGROUND\n",
 
350
                                            snapname, strerror(errno));
350
351
                                }
351
352
                        } else if (!S_ISDIR(snapdir.st_mode)) {
352
353
                                bkgrdflag = 0;
353
 
                                pfatal("%s IS NOT A DIRECTORY, %s\n", snapname,
354
 
                                    "CANNOT RUN IN BACKGROUND");
 
354
                                pfatal(
 
355
                        "%s IS NOT A DIRECTORY, CANNOT RUN IN BACKGROUND\n",
 
356
                                    snapname);
355
357
                        }
356
358
                }
357
359
                if (bkgrdflag) {
389
391
        clean:
390
392
                pwarn("clean, %ld free ", (long)(sblock.fs_cstotal.cs_nffree +
391
393
                    sblock.fs_frag * sblock.fs_cstotal.cs_nbfree));
392
 
                printf("(%lld frags, %lld blocks, %.1f%% fragmentation)\n",
393
 
                    (long long)sblock.fs_cstotal.cs_nffree,
394
 
                    (long long)sblock.fs_cstotal.cs_nbfree,
 
394
                printf("(%jd frags, %jd blocks, %.1f%% fragmentation)\n",
 
395
                    (intmax_t)sblock.fs_cstotal.cs_nffree,
 
396
                    (intmax_t)sblock.fs_cstotal.cs_nbfree,
395
397
                    sblock.fs_cstotal.cs_nffree * 100.0 / sblock.fs_dsize);
396
398
                return (0);
397
399
        }
404
406
                                if (suj_check(filesys) == 0) {
405
407
                                        printf("\n***** FILE SYSTEM MARKED CLEAN *****\n");
406
408
                                        if (chkdoreload(mntp) == 0)
407
 
                                                exit(0);
408
 
                                        exit(4);
 
409
                                                exit(1);
 
410
                                        exit(1);
409
411
                                }
410
412
                        }
411
413
                        printf("** Skipping journal, falling through to full fsck\n\n");
495
497
        blks = maxfsblock - (n_ffree + sblock.fs_frag * n_bfree) - blks;
496
498
        if (bkgrdflag && (files > 0 || blks > 0)) {
497
499
                countdirs = sblock.fs_cstotal.cs_ndir - countdirs;
498
 
                pwarn("Reclaimed: %ld directories, %ld files, %lld fragments\n",
499
 
                    countdirs, (long)files - countdirs, (long long)blks);
 
500
                pwarn("Reclaimed: %ld directories, %jd files, %jd fragments\n",
 
501
                    countdirs, files - countdirs, blks);
500
502
        }
501
503
        pwarn("%ld files, %jd used, %ju free ",
502
504
            (long)n_files, (intmax_t)n_blks,
506
508
            n_ffree * 100.0 / sblock.fs_dsize);
507
509
        if (debug) {
508
510
                if (files < 0)
509
 
                        printf("%d inodes missing\n", -files);
 
511
                        printf("%jd inodes missing\n", -files);
510
512
                if (blks < 0)
511
 
                        printf("%lld blocks missing\n", -(long long)blks);
 
513
                        printf("%jd blocks missing\n", -blks);
512
514
                if (duplist != NULL) {
513
515
                        printf("The following duplicate blocks remain:");
514
516
                        for (dp = duplist; dp; dp = dp->next)
515
 
                                printf(" %lld,", (long long)dp->dup);
 
517
                                printf(" %jd,", (intmax_t)dp->dup);
516
518
                        printf("\n");
517
519
                }
518
520
        }
650
652
usage(void)
651
653
{
652
654
        (void) fprintf(stderr,
653
 
            "usage: %s [-BEFfnpry] [-b block] [-c level] [-m mode] "
654
 
                        "filesystem ...\n",
 
655
"usage: %s [-BEFfnpry] [-b block] [-c level] [-m mode] filesystem ...\n",
655
656
            getprogname());
656
 
        exit(1);
 
657
        exit(16);
657
658
}