| /external/e2fsprogs/tests/f_jnl_64bit/ |
| D | expect.0 | 4 Revoke FS block 1536
5 Revoke FS block 1472
6 Revoke FS block 1473
7 Revoke FS block 1474
8 Revoke FS block 1475
9 Revoke FS block 1476
10 Revoke FS block 1541
11 Revoke FS block 1477
12 Revoke FS block 1478
13 Revoke FS block 1479
[all …]
|
| /external/e2fsprogs/tests/f_jnl_32bit/ |
| D | expect.0 | 4 FS block 2 logged at journal block 2 (flags 0x8)
8 FS block 82 logged at journal block 5 (flags 0x0)
9 FS block 2 logged at journal block 6 (flags 0x2)
10 FS block 99 logged at journal block 7 (flags 0x2)
11 FS block 66 logged at journal block 8 (flags 0x2)
12 FS block 81 logged at journal block 9 (flags 0x2)
13 FS block 98 logged at journal block 10 (flags 0x2)
14 FS block 68 logged at journal block 11 (flags 0x2)
15 FS block 83 logged at journal block 12 (flags 0x2)
16 FS block 354 logged at journal block 13 (flags 0x2)
[all …]
|
| /external/e2fsprogs/lib/ext2fs/ |
| D | openfs.c | 35 blk64_t ext2fs_descriptor_block_loc2(ext2_filsys fs, blk64_t group_block, in ext2fs_descriptor_block_loc2() argument
43 * On a bigalloc FS with 1K blocks, block 0 is reserved for non-ext4 in ext2fs_descriptor_block_loc2()
46 if (i == 0 && fs->blocksize == 1024 && EXT2FS_CLUSTER_RATIO(fs) > 1) in ext2fs_descriptor_block_loc2()
49 if (!ext2fs_has_feature_meta_bg(fs->super) || in ext2fs_descriptor_block_loc2()
50 (i < fs->super->s_first_meta_bg)) in ext2fs_descriptor_block_loc2()
53 bg = EXT2_DESC_PER_BLOCK(fs->super) * i; in ext2fs_descriptor_block_loc2()
54 if (ext2fs_bg_has_super(fs, bg)) in ext2fs_descriptor_block_loc2()
56 ret_blk = ext2fs_group_first_block2(fs, bg); in ext2fs_descriptor_block_loc2()
65 if (group_block != fs->super->s_first_data_block && in ext2fs_descriptor_block_loc2()
66 ((ret_blk + has_super + fs->super->s_blocks_per_group) < in ext2fs_descriptor_block_loc2()
[all …]
|
| D | blknum.c | 20 dgrp_t ext2fs_group_of_blk2(ext2_filsys fs, blk64_t blk) in ext2fs_group_of_blk2() argument
22 return (blk - fs->super->s_first_data_block) / in ext2fs_group_of_blk2()
23 fs->super->s_blocks_per_group; in ext2fs_group_of_blk2()
29 blk64_t ext2fs_group_first_block2(ext2_filsys fs, dgrp_t group) in ext2fs_group_first_block2() argument
31 return fs->super->s_first_data_block + in ext2fs_group_first_block2()
32 EXT2_GROUPS_TO_BLOCKS(fs->super, group); in ext2fs_group_first_block2()
38 blk64_t ext2fs_group_last_block2(ext2_filsys fs, dgrp_t group) in ext2fs_group_last_block2() argument
40 return (group == fs->group_desc_count - 1 ? in ext2fs_group_last_block2()
41 ext2fs_blocks_count(fs->super) - 1 : in ext2fs_group_last_block2()
42 ext2fs_group_first_block2(fs, group) + in ext2fs_group_last_block2()
[all …]
|
| D | alloc_stats.c | 18 void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino, in ext2fs_inode_alloc_stats2() argument
21 int group = ext2fs_group_of_ino(fs, ino); in ext2fs_inode_alloc_stats2()
23 if (ino > fs->super->s_inodes_count) { in ext2fs_inode_alloc_stats2()
31 ext2fs_mark_inode_bitmap2(fs->inode_map, ino); in ext2fs_inode_alloc_stats2()
33 ext2fs_unmark_inode_bitmap2(fs->inode_map, ino); in ext2fs_inode_alloc_stats2()
34 ext2fs_bg_free_inodes_count_set(fs, group, ext2fs_bg_free_inodes_count(fs, group) - inuse); in ext2fs_inode_alloc_stats2()
36 ext2fs_bg_used_dirs_count_set(fs, group, ext2fs_bg_used_dirs_count(fs, group) + inuse); in ext2fs_inode_alloc_stats2()
40 ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT); in ext2fs_inode_alloc_stats2()
41 if (ext2fs_has_group_desc_csum(fs)) { in ext2fs_inode_alloc_stats2()
42 ext2_ino_t first_unused_inode = fs->super->s_inodes_per_group - in ext2fs_inode_alloc_stats2()
[all …]
|
| D | rw_bitmaps.c | 53 static errcode_t write_bitmaps(ext2_filsys fs, int do_inode, int do_block) in write_bitmaps() argument
63 blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block); in write_bitmaps()
66 EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); in write_bitmaps()
68 if (!(fs->flags & EXT2_FLAG_RW)) in write_bitmaps()
71 csum_flag = ext2fs_has_group_desc_csum(fs); in write_bitmaps()
75 block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8; in write_bitmaps()
76 retval = io_channel_alloc_buf(fs->io, 0, &block_buf); in write_bitmaps()
79 memset(block_buf, 0xff, fs->blocksize); in write_bitmaps()
83 ((EXT2_INODES_PER_GROUP(fs->super)+7) / 8); in write_bitmaps()
84 retval = io_channel_alloc_buf(fs->io, 0, &inode_buf); in write_bitmaps()
[all …]
|
| D | closefs.c | 36 int ext2fs_bg_has_super(ext2_filsys fs, dgrp_t group) in ext2fs_bg_has_super() argument
40 if (ext2fs_has_feature_sparse_super2(fs->super)) { in ext2fs_bg_has_super()
41 if (group == fs->super->s_backup_bgs[0] || in ext2fs_bg_has_super()
42 group == fs->super->s_backup_bgs[1]) in ext2fs_bg_has_super()
46 if ((group <= 1) || !ext2fs_has_feature_sparse_super(fs->super)) in ext2fs_bg_has_super()
59 * @fs: ext2 fs pointer
71 errcode_t ext2fs_super_and_bgd_loc2(ext2_filsys fs, in ext2fs_super_and_bgd_loc2() argument
84 group_block = ext2fs_group_first_block2(fs, group); in ext2fs_super_and_bgd_loc2()
85 if (group_block == 0 && fs->blocksize == 1024) in ext2fs_super_and_bgd_loc2()
88 if (ext2fs_has_feature_meta_bg(fs->super)) in ext2fs_super_and_bgd_loc2()
[all …]
|
| D | alloc_tables.c | 38 static blk64_t flexbg_offset(ext2_filsys fs, dgrp_t group, blk64_t start_blk, in flexbg_offset() argument
46 flexbg_size = 1U << fs->super->s_log_groups_per_flex; in flexbg_offset()
50 if (size > (int) (fs->super->s_blocks_per_group / 4)) in flexbg_offset()
51 size = (int) fs->super->s_blocks_per_group / 4; in flexbg_offset()
57 if (start_blk && start_blk < ext2fs_blocks_count(fs->super) && in flexbg_offset()
58 ext2fs_get_free_blocks2(fs, start_blk, start_blk + size, elem_size, in flexbg_offset()
62 start_blk = ext2fs_group_first_block2(fs, flexbg_size * flexbg); in flexbg_offset()
64 if (last_grp > fs->group_desc_count-1) in flexbg_offset()
65 last_grp = fs->group_desc_count-1; in flexbg_offset()
66 last_blk = ext2fs_group_last_block2(fs, last_grp); in flexbg_offset()
[all …]
|
| D | mmp.c | 44 errcode_t ext2fs_mmp_read(ext2_filsys fs, blk64_t mmp_blk, void *buf) in ext2fs_mmp_read() argument
50 if ((mmp_blk <= fs->super->s_first_data_block) || in ext2fs_mmp_read()
51 (mmp_blk >= ext2fs_blocks_count(fs->super))) in ext2fs_mmp_read()
59 if (fs->mmp_fd <= 0) { in ext2fs_mmp_read()
67 * size larger than blocksize of the fs we're working with. in ext2fs_mmp_read()
69 if (stat(fs->device_name, &st) == 0 && in ext2fs_mmp_read()
73 fs->mmp_fd = open(fs->device_name, flags); in ext2fs_mmp_read()
74 if (fs->mmp_fd < 0) { in ext2fs_mmp_read()
80 if (fs->mmp_cmp == NULL) { in ext2fs_mmp_read()
81 int align = ext2fs_get_dio_alignment(fs->mmp_fd); in ext2fs_mmp_read()
[all …]
|
| D | csum.c | 33 void ext2fs_init_csum_seed(ext2_filsys fs) in ext2fs_init_csum_seed() argument
35 if (ext2fs_has_feature_csum_seed(fs->super)) in ext2fs_init_csum_seed()
36 fs->csum_seed = fs->super->s_checksum_seed; in ext2fs_init_csum_seed()
37 else if (ext2fs_has_feature_metadata_csum(fs->super) || in ext2fs_init_csum_seed()
38 ext2fs_has_feature_ea_inode(fs->super)) in ext2fs_init_csum_seed()
39 fs->csum_seed = ext2fs_crc32c_le(~0, fs->super->s_uuid, in ext2fs_init_csum_seed()
40 sizeof(fs->super->s_uuid)); in ext2fs_init_csum_seed()
43 static __u32 ext2fs_mmp_csum(ext2_filsys fs, struct mmp_struct *mmp) in ext2fs_mmp_csum() argument
47 return ext2fs_crc32c_le(fs->csum_seed, (unsigned char *)mmp, offset); in ext2fs_mmp_csum()
50 int ext2fs_mmp_csum_verify(ext2_filsys fs, struct mmp_struct *mmp) in ext2fs_mmp_csum_verify() argument
[all …]
|
| D | alloc.c | 42 void ext2fs_clear_block_uninit(ext2_filsys fs, dgrp_t group) in ext2fs_clear_block_uninit() argument
44 if (group >= fs->group_desc_count || in ext2fs_clear_block_uninit()
45 !ext2fs_has_group_desc_csum(fs) || in ext2fs_clear_block_uninit()
46 !(ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT))) in ext2fs_clear_block_uninit()
51 ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT); in ext2fs_clear_block_uninit()
52 ext2fs_group_desc_csum_set(fs, group); in ext2fs_clear_block_uninit()
53 ext2fs_mark_super_dirty(fs); in ext2fs_clear_block_uninit()
54 ext2fs_mark_bb_dirty(fs); in ext2fs_clear_block_uninit()
60 static void check_inode_uninit(ext2_filsys fs, ext2fs_inode_bitmap map, in check_inode_uninit() argument
65 if (group >= fs->group_desc_count || in check_inode_uninit()
[all …]
|
| D | inode.c | 39 ext2_filsys fs; member
52 errcode_t (*done_group)(ext2_filsys fs,
65 errcode_t ext2fs_flush_icache(ext2_filsys fs) in ext2fs_flush_icache() argument
69 if (!fs->icache) in ext2fs_flush_icache()
72 for (i=0; i < fs->icache->cache_size; i++) in ext2fs_flush_icache()
73 fs->icache->cache[i].ino = 0; in ext2fs_flush_icache()
75 fs->icache->buffer_blk = 0; in ext2fs_flush_icache()
98 errcode_t ext2fs_create_inode_cache(ext2_filsys fs, unsigned int cache_size) in ext2fs_create_inode_cache() argument
103 if (fs->icache) in ext2fs_create_inode_cache()
105 retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), &fs->icache); in ext2fs_create_inode_cache()
[all …]
|
| D | imager.c | 62 errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags) in ext2fs_image_inode_write() argument
72 buf = malloc(fs->blocksize * BUF_BLOCKS); in ext2fs_image_inode_write()
76 for (group = 0; group < fs->group_desc_count; group++) { in ext2fs_image_inode_write()
77 blk = ext2fs_inode_table_loc(fs, group); in ext2fs_image_inode_write()
82 left = fs->inode_blocks_per_group; in ext2fs_image_inode_write()
83 if ((blk < fs->super->s_first_data_block) || in ext2fs_image_inode_write()
84 (blk + left - 1 >= ext2fs_blocks_count(fs->super))) { in ext2fs_image_inode_write()
92 retval = io_channel_read_blk64(fs->io, blk, c, buf); in ext2fs_image_inode_write()
102 if (check_zero_block(cp, fs->blocksize)) { in ext2fs_image_inode_write()
106 cp += fs->blocksize; in ext2fs_image_inode_write()
[all …]
|
| D | freefs.c | 22 void ext2fs_free(ext2_filsys fs) in ext2fs_free() argument
24 if (!fs || (fs->magic != EXT2_ET_MAGIC_EXT2FS_FILSYS)) in ext2fs_free()
26 if (fs->image_io != fs->io) { in ext2fs_free()
27 if (fs->image_io) in ext2fs_free()
28 io_channel_close(fs->image_io); in ext2fs_free()
30 if (fs->io) { in ext2fs_free()
31 io_channel_close(fs->io); in ext2fs_free()
33 if (fs->device_name) in ext2fs_free()
34 ext2fs_free_mem(&fs->device_name); in ext2fs_free()
35 if (fs->super) in ext2fs_free()
[all …]
|
| D | ext2fs.h | 128 ext2_filsys fs; member
261 errcode_t (*get_blocks)(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
262 errcode_t (*check_directory)(ext2_filsys fs, ext2_ino_t ino);
263 errcode_t (*write_bitmaps)(ext2_filsys fs);
264 errcode_t (*read_inode)(ext2_filsys fs, ext2_ino_t ino,
266 errcode_t (*write_inode)(ext2_filsys fs, ext2_ino_t ino,
297 errcode_t (*get_alloc_block)(ext2_filsys fs, blk64_t goal,
299 errcode_t (*get_alloc_block2)(ext2_filsys fs, blk64_t goal,
301 void (*block_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
318 /* Precomputed FS UUID checksum for seeding other checksums */
[all …]
|
| /external/sdv/vsomeip/third_party/boost/filesystem/test/ |
| D | operations_test.cpp | 35 namespace fs = boost::filesystem;
69 inline void setenv_(const char* name, const fs::path::value_type* val, int) in setenv_()
120 fs::directory_iterator end_itr;
121 fs::path dir;
122 fs::path d1;
123 fs::path d2;
124 fs::path f0;
125 fs::path f1;
126 fs::path d1f1;
130 fs::path ng(" no-way, Jose");
[all …]
|
| D | copy_test.cpp | 35 namespace fs = boost::filesystem;
39 void create_file(fs::path const& ph, std::string const& contents = std::string()) in create_file()
48 void verify_file(fs::path const& ph, std::string const& expected) in verify_file()
62 fs::path create_tree() in create_tree()
64 fs::path root_dir = fs::unique_path(); in create_tree()
66 fs::create_directory(root_dir); in create_tree()
70 fs::create_directory(root_dir / "d1"); in create_tree()
73 fs::create_directory(root_dir / "d1/d1"); in create_tree()
76 fs::create_directory(root_dir / "d1/d2"); in create_tree()
78 fs::create_directory(root_dir / "d2"); in create_tree()
[all …]
|
| /external/e2fsprogs/debugfs/ |
| D | filefrag.c | 69 static void print_header(struct filefrag_struct *fs) in print_header() argument
71 if (fs->options & VERBOSE_OPT) { in print_header()
72 fprintf(fs->f, "%4s %*s %*s %*s %*s\n", "ext", in print_header()
73 fs->logical_width, "logical", fs->physical_width, in print_header()
74 "physical", fs->physical_width, "expected", in print_header()
75 fs->logical_width, "length"); in print_header()
79 static void report_filefrag(struct filefrag_struct *fs) in report_filefrag() argument
81 if (fs->num == 0) in report_filefrag()
83 if (fs->options & VERBOSE_OPT) { in report_filefrag()
84 if (fs->expected) in report_filefrag()
[all …]
|
| /external/lua/src/ |
| D | lcode.c | 40 static int codesJ (FuncState *fs, OpCode o, int sj, int k);
73 static TValue *const2val (FuncState *fs, const expdesc *e) { in const2val() argument
75 return &fs->ls->dyd->actvar.arr[e->u.info].k; in const2val()
83 int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { in luaK_exp2const() argument
97 setsvalue(fs->ls->L, v, e->u.strval); in luaK_exp2const()
101 setobj(fs->ls->L, v, const2val(fs, e)); in luaK_exp2const()
115 static Instruction *previousinstruction (FuncState *fs) { in previousinstruction() argument
117 if (fs->pc > fs->lasttarget) in previousinstruction()
118 return &fs->f->code[fs->pc - 1]; /* previous instruction */ in previousinstruction()
130 void luaK_nil (FuncState *fs, int from, int n) { in luaK_nil() argument
[all …]
|
| /external/mtools/ |
| D | mformat.c | 45 #include "linux/fs.h"
177 static __inline__ void format_root(Fs_t *Fs, char *label, union bootsector *boot) in format_root() argument
189 buf = safe_malloc(Fs->sector_size); in format_root()
190 RootDir = OpenRoot((Stream_t *)Fs); in format_root()
196 memset(buf, '\0', Fs->sector_size); in format_root()
198 if(Fs->fat_bits == 32) { in format_root()
201 dirlen = Fs->cluster_size; in format_root()
202 fatAllocate(Fs, Fs->rootCluster, Fs->end_fat); in format_root()
204 dirlen = Fs->dir_len; in format_root()
206 PWRITES(RootDir, buf, sectorsToBytes(Fs, i), in format_root()
[all …]
|
| /external/e2fsprogs/e2fsck/ |
| D | super.c | 82 static int release_inode_block(ext2_filsys fs, in release_inode_block() argument
93 blk64_t cluster = EXT2FS_B2C(fs, *block_nr); in release_inode_block()
111 if ((blk < fs->super->s_first_data_block) || in release_inode_block()
112 (blk >= ext2fs_blocks_count(fs->super))) { in release_inode_block()
119 if (!ext2fs_test_block_bitmap2(fs->block_map, blk)) { in release_inode_block()
138 pb->errcode = io_channel_read_blk64(fs->io, blk, 1, in release_inode_block()
143 limit = fs->blocksize >> 2; in release_inode_block()
160 pb->errcode = io_channel_read_blk64(fs->io, blk, 1, in release_inode_block()
165 fs->blocksize - pb->truncate_offset); in release_inode_block()
166 pb->errcode = io_channel_write_blk64(fs->io, blk, 1, in release_inode_block()
[all …]
|
| D | pass5.c | 42 init_resource_track(&rtrack, ctx->fs->io); in e2fsck_pass5()
49 if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2)) in e2fsck_pass5()
79 print_resource_track(ctx, _("Pass 5"), &rtrack, ctx->fs->io); in e2fsck_pass5()
91 if (!ext2fs_has_feature_metadata_csum(ctx->fs->super)) in check_inode_bitmap_checksum()
95 if (ext2fs_test_ib_dirty(ctx->fs)) in check_inode_bitmap_checksum()
98 nbytes = (size_t)(EXT2_INODES_PER_GROUP(ctx->fs->super) / 8); in check_inode_bitmap_checksum()
99 retval = ext2fs_get_mem(ctx->fs->blocksize, &buf); in check_inode_bitmap_checksum()
107 for (i = 0; i < ctx->fs->group_desc_count; i++) { in check_inode_bitmap_checksum()
108 if (ext2fs_bg_flags_test(ctx->fs, i, EXT2_BG_INODE_UNINIT)) in check_inode_bitmap_checksum()
112 retval = ext2fs_get_inode_bitmap_range2(ctx->fs->inode_map, in check_inode_bitmap_checksum()
[all …]
|
| /external/e2fsprogs/resize/ |
| D | resize2fs.c | 44 static void fix_uninit_block_bitmaps(ext2_filsys fs);
51 static errcode_t fix_resize_inode(ext2_filsys fs);
52 static errcode_t resize2fs_calculate_summary_stats(ext2_filsys fs);
53 static errcode_t fix_sb_journal_backup(ext2_filsys fs);
54 static errcode_t mark_table_blocks(ext2_filsys fs,
66 static inline int is_block_bm(ext2_filsys fs, unsigned int grp, blk64_t blk) in is_block_bm() argument
68 return blk == ext2fs_block_bitmap_loc(fs, grp); in is_block_bm()
71 static inline int is_inode_bm(ext2_filsys fs, unsigned int grp, blk64_t blk) in is_inode_bm() argument
73 return blk == ext2fs_inode_bitmap_loc(fs, grp); in is_inode_bm()
76 static int is_inode_tb(ext2_filsys fs, unsigned int grp, blk64_t blk) in is_inode_tb() argument
[all …]
|
| /external/cronet/third_party/libc++/src/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/ |
| D | relative.pass.cpp | 28 namespace fs = std::filesystem;
31 fs::path p(""); in test_signature_0()
32 const fs::path output = fs::weakly_canonical(p); in test_signature_0()
33 assert(output == fs::path::string_type(fs::current_path())); in test_signature_0()
37 fs::path p("."); in test_signature_1()
38 const fs::path output = fs::weakly_canonical(p); in test_signature_1()
39 assert(output == fs::path::string_type(fs::current_path())); in test_signature_1()
44 fs::path p(static_env.File); in test_signature_2()
45 const fs::path output = fs::weakly_canonical(p); in test_signature_2()
46 assert(output == fs::path::string_type(static_env.File)); in test_signature_2()
[all …]
|
| /external/e2fsprogs/misc/ |
| D | fuse2fs.c | 19 # include <linux/fs.h>
96 errcode_t ext2fs_run_ext3_journal(ext2_filsys *fs);
147 * ext4 ACL structures, copied from fs/ext4/acl.h.
317 ext2_filsys fs; member
333 #define FUSE2FS_CHECK_MAGIC(fs, ptr, num) do {if ((ptr)->magic != (num)) \ argument
334 return translate_error((fs), 0, EXT2_ET_MAGIC_EXT2_FILE); \
341 static int __translate_error(ext2_filsys fs, errcode_t err, ext2_ino_t ino,
343 #define translate_error(fs, ino, err) __translate_error((fs), (err), (ino), \ argument
473 static int update_ctime(ext2_filsys fs, ext2_ino_t ino, in update_ctime() argument
491 err = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode, in update_ctime()
[all …]
|