Lines Matching defs:fs
34 #include <fs/nandfs/nandfs_fs.h>
125 #define NINDIR(fs) ((fs)->nf_blocksize / sizeof(nandfs_daddr_t))
195 nandfs_find_super_block(struct nandfs *fs, struct open_file *f)
201 sb = malloc(fs->nf_sectorsize);
205 memset(fs->nf_sb, 0, sizeof(*fs->nf_sb));
207 sectors_to_read = (NANDFS_NFSAREAS * fs->nf_fsdata->f_erasesize) /
208 fs->nf_sectorsize;
211 i * fs->nf_sectorsize);
212 error = ioread(f, i * fs->nf_sectorsize, (char *)sb,
213 fs->nf_sectorsize);
218 n = fs->nf_sectorsize / sizeof(struct nandfs_super_block);
220 if ((i * fs->nf_sectorsize) % fs->nf_fsdata->f_erasesize == 0) {
221 if (fs->nf_sectorsize == sizeof(struct nandfs_fsdata))
230 if (!nandfs_check_superblock_crc(fs->nf_fsdata, &sb[j]))
234 if (sb[j].s_last_cno > fs->nf_sb->s_last_cno)
235 memcpy(fs->nf_sb, &sb[j], sizeof(*fs->nf_sb));
241 return (fs->nf_sb->s_magic != 0 ? 0 : EINVAL);
245 nandfs_find_fsdata(struct nandfs *fs, struct open_file *f)
253 error = ioread(f, offset, (char *)fs->nf_fsdata,
257 if (fs->nf_fsdata->f_magic == NANDFS_FSDATA_MAGIC) {
259 fs->nf_fsdata->f_volume_name);
260 if (nandfs_check_fsdata_crc(fs->nf_fsdata))
263 offset += fs->nf_sectorsize;
270 nandfs_read_structures(struct nandfs *fs, struct open_file *f)
274 error = nandfs_find_fsdata(fs, f);
278 error = nandfs_find_super_block(fs, f);
282 fs->nf_sb->s_wtime, fs->nf_sb->s_last_pseg);
288 nandfs_mount(struct nandfs *fs, struct open_file *f)
293 fs->nf_fsdata = malloc(sizeof(struct nandfs_fsdata));
294 fs->nf_sb = malloc(sizeof(struct nandfs_super_block));
296 err = nandfs_read_structures(fs, f);
298 free(fs->nf_fsdata);
299 free(fs->nf_sb);
303 fs->nf_blocksize = 1 << (fs->nf_fsdata->f_log_block_size + 10);
305 NANDFS_DEBUG("using superblock with wtime %jd\n", fs->nf_sb->s_wtime);
307 fs->nf_cpno = fs->nf_sb->s_last_cno;
308 last_pseg = fs->nf_sb->s_last_pseg;
317 mult *= NINDIR(fs);
318 fs->nf_nindir[level] = mult;
321 nandfs_calc_mdt_consts(fs->nf_blocksize, &fs->nf_datfile_mdt,
322 fs->nf_fsdata->f_dat_entry_size);
324 nandfs_calc_mdt_consts(fs->nf_blocksize, &fs->nf_ifile_mdt,
325 fs->nf_fsdata->f_inode_size);
327 err = ioread(f, last_pseg * fs->nf_blocksize, &fs->nf_segsum,
330 free(fs->nf_sb);
331 free(fs->nf_fsdata);
335 err = ioread(f, (last_pseg + fs->nf_segsum.ss_nblocks - 1) *
336 fs->nf_blocksize, &fs->nf_sroot, sizeof(struct nandfs_super_root));
338 free(fs->nf_sb);
339 free(fs->nf_fsdata);
343 fs->nf_datfile.inode = &fs->nf_sroot.sr_dat;
344 LIST_INIT(&fs->nf_datfile.bmap_bufs);
345 fs->nf_cpfile.inode = &fs->nf_sroot.sr_cpfile;
346 LIST_INIT(&fs->nf_cpfile.bmap_bufs);
348 err = nandfs_get_checkpoint(fs, fs->nf_cpno, &fs->nf_checkpoint);
350 free(fs->nf_sb);
351 free(fs->nf_fsdata);
355 NANDFS_DEBUG("checkpoint cp_cno=%lld\n", fs->nf_checkpoint.cp_cno);
357 fs->nf_checkpoint.cp_inodes_count);
359 fs->nf_checkpoint.cp_ifile_inode.i_blocks);
361 fs->nf_ifile.inode = &fs->nf_checkpoint.cp_ifile_inode;
362 LIST_INIT(&fs->nf_ifile.bmap_bufs);
366 #define NINDIR(fs) ((fs)->nf_blocksize / sizeof(nandfs_daddr_t))
371 struct nandfs *fs;
377 fs = malloc(sizeof(struct nandfs));
378 f->f_fsdata = fs;
379 fs->nf_file = f;
387 fs->nf_sectorsize = bsize;
396 mult *= NINDIR(fs);
397 fs->nf_nindir[level] = mult;
400 NANDFS_DEBUG("fs %p nf_sectorsize=%x\n", fs, fs->nf_sectorsize);
402 err = nandfs_mount(fs, f);
408 node = nandfs_lookup_path(fs, path);
412 fs->nf_offset = 0;
413 fs->nf_buf = NULL;
414 fs->nf_buf_blknr = -1;
415 fs->nf_opened_node = node;
416 LIST_INIT(&fs->nf_opened_node->bmap_bufs);
437 struct nandfs *fs = f->f_fsdata;
441 if (fs->nf_buf != NULL)
442 free(fs->nf_buf);
444 nandfs_free_node(fs->nf_opened_node);
445 free(fs->nf_sb);
446 free(fs);
453 struct nandfs *fs = (struct nandfs *)f->f_fsdata;
461 if (fs->nf_offset >= fs->nf_opened_node->inode->i_size)
464 error = nandfs_buf_read(fs, &buf, &buf_size);
474 fs->nf_offset += csize;
487 struct nandfs *fs = f->f_fsdata;
494 size = fs->nf_opened_node->inode->i_size;
501 off = fs->nf_offset;
517 fs->nf_offset = (u_int)off;
525 struct nandfs *fs = f->f_fsdata;
529 sb->st_size = fs->nf_opened_node->inode->i_size;
530 sb->st_mode = fs->nf_opened_node->inode->i_mode;
531 sb->st_uid = fs->nf_opened_node->inode->i_uid;
532 sb->st_gid = fs->nf_opened_node->inode->i_gid;
539 struct nandfs *fs = f->f_fsdata;
546 if (fs->nf_offset >= fs->nf_opened_node->inode->i_size) {
552 if (nandfs_buf_read(fs, &buf, &buf_size)) {
562 fs->nf_offset += dirent->rec_len;
570 nandfs_buf_read(struct nandfs *fs, void **buf_p, size_t *size_p)
574 blknr = fs->nf_offset / fs->nf_blocksize;
575 blkoff = fs->nf_offset % fs->nf_blocksize;
577 if (blknr != fs->nf_buf_blknr) {
578 if (fs->nf_buf == NULL)
579 fs->nf_buf = malloc(fs->nf_blocksize);
581 if (nandfs_read_inode(fs, fs->nf_opened_node, blknr, 1,
582 fs->nf_buf, 0))
585 fs->nf_buf_blknr = blknr;
588 *buf_p = fs->nf_buf + blkoff;
589 *size_p = fs->nf_blocksize - blkoff;
593 if (*size_p > fs->nf_opened_node->inode->i_size - fs->nf_offset)
594 *size_p = fs->nf_opened_node->inode->i_size - fs->nf_offset;
600 nandfs_lookup_node(struct nandfs *fs, uint64_t ino)
615 buffer = malloc(fs->nf_blocksize);
619 nandfs_mdt_trans(&fs->nf_ifile_mdt, ino, &blocknr, &entrynr);
621 if (nandfs_read_inode(fs, &fs->nf_ifile, blocknr, 1, buffer, 0))
631 nandfs_lookup_path(struct nandfs *fs, const char *path)
641 buffer = malloc(fs->nf_blocksize);
651 node = nandfs_lookup_node(fs, NANDFS_ROOT_INO);
666 if (nandfs_read_inode(fs, node, i, 1, orig, 0)) {
686 node = nandfs_lookup_node(fs,
697 if (counter == fs->nf_blocksize)
724 if (nandfs_read_inode(fs, node, 0, 1, orig, 0)) {
757 node = nandfs_lookup_node(fs, inode);
768 nandfs_read_inode(struct nandfs *fs, struct nandfs_node *node,
779 NANDFS_DEBUG("nandfs_read_inode fs=%p node=%p blknr=%lld nblks=%d\n",
780 fs, node, blknr, nblks);
782 error = nandfs_bmap_lookup(fs, node, blknr + i, &vblks[i], raw);
789 pblks[i] = nandfs_vtop(fs, vblks[i]);
795 if (ioread(fs->nf_file, pblks[i] * fs->nf_blocksize, buf,
796 fs->nf_blocksize)) {
802 buf = (void *)((uintptr_t)buf + fs->nf_blocksize);
811 nandfs_read_blk(struct nandfs *fs, nandfs_daddr_t blknr, void *buf, int phys)
815 pblknr = (phys ? blknr : nandfs_vtop(fs, blknr));
817 return (ioread(fs->nf_file, pblknr * fs->nf_blocksize, buf,
818 fs->nf_blocksize));
822 nandfs_get_checkpoint(struct nandfs *fs, uint64_t cpno,
829 NANDFS_DEBUG("nandfs_get_checkpoint(fs=%p cpno=%lld)\n", fs, cpno);
831 buf = malloc(fs->nf_blocksize);
834 dlen = fs->nf_fsdata->f_checkpoint_size;
835 cp_per_block = fs->nf_blocksize / dlen;
839 if (nandfs_read_inode(fs, &fs->nf_cpfile, blocknr, 1, buf, 0)) {
851 nandfs_get_map(struct nandfs *fs, struct nandfs_node *node, nandfs_daddr_t blknr,
862 map = malloc(fs->nf_blocksize);
863 if (nandfs_read_blk(fs, blknr, map, phys)) {
879 nandfs_bmap_lookup(struct nandfs *fs, struct nandfs_node *node,
904 NANDFS_DEBUG("lblknr=%jx fs->nf_nindir[%d]=%d\n", lblknr, level, fs->nf_nindir[level]);
905 if (lblknr < fs->nf_nindir[level])
907 lblknr -= fs->nf_nindir[level];
926 map = nandfs_get_map(fs, node, ind_block_num, phys);
931 idx = lblknr / fs->nf_nindir[level - 1];
932 lblknr %= fs->nf_nindir[level - 1];
945 nandfs_vtop(struct nandfs *fs, nandfs_daddr_t vblocknr)
952 dat = malloc(fs->nf_blocksize);
953 nandfs_mdt_trans(&fs->nf_datfile_mdt, vblocknr, &blocknr, &entrynr);
955 if (nandfs_read_inode(fs, &fs->nf_datfile, blocknr, 1, dat, 1)) {