struct dentry *hpfs_lookup(struct inode *dir, struct dentry *dentry) { const char *name = dentry->d_name.name; unsigned len = dentry->d_name.len; struct quad_buffer_head qbh; struct hpfs_dirent *de; ino_t ino; int err; struct inode *result = NULL; if ((err = hpfs_chk_name((char *)name, &len))) { if (err == -ENAMETOOLONG) return ERR_PTR(-ENAMETOOLONG); goto end_add; } hpfs_lock_inode(dir); /* * '.' and '..' will never be passed here. */ de = map_dirent(dir, dir->i_hpfs_dno, (char *) name, len, NULL, &qbh); /* * This is not really a bailout, just means file not found. */ if (!de) goto end; /* * Get inode number, what we're after. */ ino = de->fnode; /* * Go find or make an inode. */ hpfs_lock_iget(dir->i_sb, de->directory || (de->ea_size && dir->i_sb->s_hpfs_eas) ? 1 : 2); if (!(result = iget(dir->i_sb, ino))) { hpfs_unlock_iget(dir->i_sb); hpfs_error(dir->i_sb, "hpfs_lookup: can't get inode"); goto bail1; } if (!de->directory) result->i_hpfs_parent_dir = dir->i_ino; hpfs_unlock_iget(dir->i_sb); hpfs_decide_conv(result, (char *)name, len); if (de->has_acl || de->has_xtd_perm) if (!(dir->i_sb->s_flags & MS_RDONLY)) { hpfs_error(result->i_sb, "ACLs or XPERM found. This is probably HPFS386. This driver doesn't support it now. Send me some info on these structures"); goto bail1; } /* * Fill in the info from the directory if this is a newly created * inode. */ if (!result->i_ctime) { if (!(result->i_ctime = local_to_gmt(dir->i_sb, de->creation_date))) result->i_ctime = 1; result->i_mtime = local_to_gmt(dir->i_sb, de->write_date); result->i_atime = local_to_gmt(dir->i_sb, de->read_date); result->i_hpfs_ea_size = de->ea_size; if (!result->i_hpfs_ea_mode && de->read_only) result->i_mode &= ~0222; if (!de->directory) { if (result->i_size == -1) { result->i_size = de->file_size; result->i_data.a_ops = &hpfs_aops; result->u.hpfs_i.mmu_private = result->i_size; /* * i_blocks should count the fnode and any anodes. * We count 1 for the fnode and don't bother about * anodes -- the disk heads are on the directory band * and we want them to stay there. */ result->i_blocks = 1 + ((result->i_size + 511) >> 9); } } }
struct super_block *hpfs_read_super(struct super_block *s, void *options, int silent) { kdev_t dev; struct buffer_head *bh0, *bh1, *bh2; struct hpfs_boot_block *bootblock; struct hpfs_super_block *superblock; struct hpfs_spare_block *spareblock; uid_t uid; gid_t gid; umode_t umask; int lowercase, conv, eas, chk, errs, chkdsk, timeshift; dnode_secno root_dno; struct hpfs_dirent *de = NULL; struct quad_buffer_head qbh; int o; s->s_hpfs_bmp_dir = NULL; s->s_hpfs_cp_table = NULL; s->s_hpfs_creation_de_lock = s->s_hpfs_rd_inode = 0; init_waitqueue_head(&s->s_hpfs_creation_de); init_waitqueue_head(&s->s_hpfs_iget_q); uid = current->uid; gid = current->gid; umask = current->fs->umask; lowercase = 0; conv = CONV_BINARY; eas = 2; chk = 1; errs = 1; chkdsk = 1; timeshift = 0; if (!(o = parse_opts(options, &uid, &gid, &umask, &lowercase, &conv, &eas, &chk, &errs, &chkdsk, ×hift))) { printk("HPFS: bad mount options.\n"); goto bail0; } if (o==2) { hpfs_help(); goto bail0; } /*s->s_hpfs_mounting = 1;*/ dev = s->s_dev; set_blocksize(dev, 512); s->s_hpfs_fs_size = -1; if (!(bootblock = hpfs_map_sector(s, 0, &bh0, 0))) goto bail1; if (!(superblock = hpfs_map_sector(s, 16, &bh1, 1))) goto bail2; if (!(spareblock = hpfs_map_sector(s, 17, &bh2, 0))) goto bail3; /* Check magics */ if (/*bootblock->magic != BB_MAGIC ||*/ superblock->magic != SB_MAGIC || spareblock->magic != SP_MAGIC) { if (!silent) printk("HPFS: Bad magic ... probably not HPFS\n"); goto bail4; } /* Check version */ if (!(s->s_flags & MS_RDONLY) && superblock->funcversion != 2 && superblock->funcversion != 3) { printk("HPFS: Bad version %d,%d. Mount readonly to go around\n", (int)superblock->version, (int)superblock->funcversion); printk("HPFS: please try recent version of HPFS driver at http://artax.karlin.mff.cuni.cz/~mikulas/vyplody/hpfs/index-e.cgi and if it still can't understand this format, contact author - [email protected]\n"); goto bail4; } s->s_flags |= MS_NOATIME; /* Fill superblock stuff */ s->s_magic = HPFS_SUPER_MAGIC; s->s_blocksize = 512; s->s_blocksize_bits = 9; s->s_op = &hpfs_sops; s->s_hpfs_root = superblock->root; s->s_hpfs_fs_size = superblock->n_sectors; s->s_hpfs_bitmaps = superblock->bitmaps; s->s_hpfs_dirband_start = superblock->dir_band_start; s->s_hpfs_dirband_size = superblock->n_dir_band; s->s_hpfs_dmap = superblock->dir_band_bitmap; s->s_hpfs_uid = uid; s->s_hpfs_gid = gid; s->s_hpfs_mode = 0777 & ~umask; s->s_hpfs_n_free = -1; s->s_hpfs_n_free_dnodes = -1; s->s_hpfs_lowercase = lowercase; s->s_hpfs_conv = conv; s->s_hpfs_eas = eas; s->s_hpfs_chk = chk; s->s_hpfs_chkdsk = chkdsk; s->s_hpfs_err = errs; s->s_hpfs_timeshift = timeshift; s->s_hpfs_was_error = 0; s->s_hpfs_cp_table = NULL; s->s_hpfs_c_bitmap = -1; /* Load bitmap directory */ if (!(s->s_hpfs_bmp_dir = hpfs_load_bitmap_directory(s, superblock->bitmaps))) goto bail4; /* Check for general fs errors*/ if (spareblock->dirty && !spareblock->old_wrote) { if (errs == 2) { printk("HPFS: Improperly stopped, not mounted\n"); goto bail4; } hpfs_error(s, "improperly stopped"); } if (!(s->s_flags & MS_RDONLY)) { spareblock->dirty = 1; spareblock->old_wrote = 0; mark_buffer_dirty(bh2); } if (spareblock->hotfixes_used || spareblock->n_spares_used) { if (errs >= 2) { printk("HPFS: Hotfixes not supported here, try chkdsk\n"); mark_dirty(s); goto bail4; } hpfs_error(s, "hotfixes not supported here, try chkdsk"); if (errs == 0) printk("HPFS: Proceeding, but your filesystem will be probably corrupted by this driver...\n"); else printk("HPFS: This driver may read bad files or crash when operating on disk with hotfixes.\n"); } if (spareblock->n_dnode_spares != spareblock->n_dnode_spares_free) { if (errs >= 2) { printk("HPFS: Spare dnodes used, try chkdsk\n"); mark_dirty(s); goto bail4; } hpfs_error(s, "warning: spare dnodes used, try chkdsk"); if (errs == 0) printk("HPFS: Proceeding, but your filesystem could be corrupted if you delete files or directories\n"); } if (chk) { unsigned a; if (superblock->dir_band_end - superblock->dir_band_start + 1 != superblock->n_dir_band || superblock->dir_band_end < superblock->dir_band_start || superblock->n_dir_band > 0x4000) { hpfs_error(s, "dir band size mismatch: dir_band_start==%08x, dir_band_end==%08x, n_dir_band==%08x", superblock->dir_band_start, superblock->dir_band_end, superblock->n_dir_band); goto bail4; } a = s->s_hpfs_dirband_size; s->s_hpfs_dirband_size = 0; if (hpfs_chk_sectors(s, superblock->dir_band_start, superblock->n_dir_band, "dir_band") || hpfs_chk_sectors(s, superblock->dir_band_bitmap, 4, "dir_band_bitmap") || hpfs_chk_sectors(s, superblock->bitmaps, 4, "bitmaps")) { mark_dirty(s); goto bail4; } s->s_hpfs_dirband_size = a; } else printk("HPFS: You really don't want any checks? You are crazy...\n"); /* Load code page table */ if (spareblock->n_code_pages) if (!(s->s_hpfs_cp_table = hpfs_load_code_page(s, spareblock->code_page_dir))) printk("HPFS: Warning: code page support is disabled\n"); brelse(bh2); brelse(bh1); brelse(bh0); hpfs_lock_iget(s, 1); s->s_root = d_alloc_root(iget(s, s->s_hpfs_root)); hpfs_unlock_iget(s); if (!s->s_root || !s->s_root->d_inode) { printk("HPFS: iget failed. Why???\n"); goto bail0; } hpfs_set_dentry_operations(s->s_root); /* * find the root directory's . pointer & finish filling in the inode */ root_dno = hpfs_fnode_dno(s, s->s_hpfs_root); if (root_dno) de = map_dirent(s->s_root->d_inode, root_dno, "\001\001", 2, NULL, &qbh); if (!root_dno || !de) hpfs_error(s, "unable to find root dir"); else { s->s_root->d_inode->i_atime = local_to_gmt(s, de->read_date); s->s_root->d_inode->i_mtime = local_to_gmt(s, de->write_date); s->s_root->d_inode->i_ctime = local_to_gmt(s, de->creation_date); s->s_root->d_inode->i_hpfs_ea_size = de->ea_size; s->s_root->d_inode->i_hpfs_parent_dir = s->s_root->d_inode->i_ino; if (s->s_root->d_inode->i_size == -1) s->s_root->d_inode->i_size = 2048; if (s->s_root->d_inode->i_blocks == -1) s->s_root->d_inode->i_blocks = 5; } if (de) hpfs_brelse4(&qbh); return s; bail4: brelse(bh2); bail3: brelse(bh1); bail2: brelse(bh0); bail1: bail0: if (s->s_hpfs_bmp_dir) kfree(s->s_hpfs_bmp_dir); if (s->s_hpfs_cp_table) kfree(s->s_hpfs_cp_table); return NULL; }