/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #ifndef _SYS_FS_UDF_INODE_H #define _SYS_FS_UDF_INODE_H #include #ifdef __cplusplus extern "C" { #endif #define SUN_IMPL_ID "*SUN SOLARIS UDF" #define SUN_IMPL_ID_LEN 16 #define SUN_OS_CLASS 4 #define SUN_OS_ID 2 /* * Size of each cluster * and bits to be shifted */ #define CLSTR_SIZE 8 #define CLSTR_MASK 7 /* * enums */ enum de_op { DE_CREATE, DE_MKDIR, DE_LINK, DE_RENAME }; /* direnter ops */ enum dr_op { DR_REMOVE, DR_RMDIR, DR_RENAME }; /* dirremove ops */ /* * The following macros optimize certain frequently calculated * quantities by using shifts and masks in place of divisions * modulos and multiplications. */ #define blkoff(udfvfsp, loc) /* calculates (loc % udfcfs->udf_lbsize) */ \ ((loc) & (udfvfsp)->udf_lbmask) #define lblkno(udf_vfsp, loc) \ ((int32_t)((loc) / (udf_vfsp)->udf_lbsize)) #define fsbtodb(udf, blk) \ ((blk) << udf->udf_l2d_shift) struct udf_fid { uint16_t udfid_len; /* Length of data */ uint16_t udfid_prn; /* the partition number of icb */ uint32_t udfid_icb_lbn; /* file entry block no */ uint32_t udfid_uinq_lo; /* uniq id to validate the vnode */ }; #define MAXNAMLEN 255 struct ud_part { uint16_t udp_flags; /* See below */ uint16_t udp_number; /* partition Number */ uint32_t udp_seqno; /* to find the prevailaing desc */ uint32_t udp_access; /* access type */ uint32_t udp_start; /* Starting block no of partition */ uint32_t udp_length; /* Lenght of the partition */ uint32_t udp_unall_loc; /* unall space tbl or bitmap loc */ uint32_t udp_unall_len; /* unall space tbl or bitmap length */ uint32_t udp_freed_loc; /* freed space tbl or bitmap loc */ uint32_t udp_freed_len; /* freed space tbl or bitmap length */ /* From part desc */ uint32_t udp_nfree; /* No of free blocks in the partition */ uint32_t udp_nblocks; /* Total no of blks in the partition */ /* From lvid */ uint32_t udp_last_alloc; /* Last allocated space in bitmap */ int32_t udp_cache_count; /* Cache is used for metadata */ daddr_t udp_cache[CLSTR_SIZE]; }; /* * udp_flags */ #define UDP_BITMAPS 0x00 #define UDP_SPACETBLS 0x01 /* * udp_access */ #define UDP_MT_RO 0x0001 /* ROM */ #define UDP_MT_WO 0x0002 /* WORM */ #define UDP_MT_RW 0x0003 /* RW */ #define UDP_MT_OW 0x0004 /* OW */ #define MAX_SPM 4 struct ud_map { uint32_t udm_flags; /* Flags */ uint16_t udm_vsn; /* Volume Sequence Number */ uint16_t udm_pn; /* Partition Number */ uint32_t udm_vat_icb; /* VAT ICB location */ uint32_t udm_nent; /* Number of vat entries */ uint32_t *udm_count; /* Number of entrues in each table */ struct buf **udm_bp; /* VAT translation tables */ uint32_t **udm_addr; int32_t udm_plen; int32_t udm_nspm; uint32_t udm_spsz; uint32_t udm_loc[MAX_SPM]; struct buf *udm_sbp[MAX_SPM]; caddr_t udm_spaddr[MAX_SPM]; }; /* * udm_flags */ #define UDM_MAP_NORM 0x00 #define UDM_MAP_VPM 0x01 #define UDM_MAP_SPM 0x02 struct udf_vfs { struct vfs *udf_vfs; /* Back link */ struct udf_vfs *udf_next; /* Chain of udf file-system's */ struct udf_vfs *udf_wnext; /* work list link */ struct buf *udf_vds; /* most of the superblock */ struct buf *udf_iseq; /* Integrity of the fs */ struct vnode *udf_root; /* Root vnode */ struct vnode *udf_devvp; /* Block device vnode */ char *udf_fsmnt; /* Path name of directory mouted on */ uint32_t udf_flags; /* Flags */ uint32_t udf_mtype; /* Media type */ int32_t udf_rdclustsz; /* read cluster size */ int32_t udf_wrclustsz; /* write cluster size */ uint64_t udf_maxfsize; /* Max file size allowed in this fs */ int32_t udf_maxfbits; /* No of bit's for max file size */ char udf_volid[32]; /* volume identifier */ /* from pvd */ uint16_t udf_tsno; /* Taken from pvd and */ /* used in making tags */ int32_t udf_lbsize; /* Block size */ /* from lvd */ int32_t udf_lbmask; /* udf_lbsize - 1 */ int32_t udf_l2b_shift; /* lbsize to bytes */ int32_t udf_l2d_shift; /* right shift's to */ /* make lbsize to DEV_BSIZE */ int32_t udf_npart; /* No. of partition's in the volume */ /* restricted to 1 till udf 1.50 */ struct ud_part *udf_parts; /* pointer to array of partitions */ /* from part desc's */ int32_t udf_nmaps; struct ud_map *udf_maps; int32_t udf_fragmented; /* File System fragmented */ int32_t udf_mark_bad; /* force fsck at next mount */ /* * sum of udp_nfree and udp_nblocks * from the array udf_parts[0] to udf_parts[udf_nparts - 1] */ uint32_t udf_freeblks; /* Total udf_lbsize Free Blocks */ uint32_t udf_totalblks; /* Total number of Blocks */ /* udf_parts[0].udp_nfree == udf_freespace */ /* till udf 1.50 (DVD-R?) */ uint64_t udf_maxuniq; /* Maximum unique ID on the fs */ uint32_t udf_nfiles; /* No of files */ uint32_t udf_ndirs; /* No of directories */ uint32_t udf_miread; /* minimum read revision */ uint32_t udf_miwrite; /* minimum write revision */ uint32_t udf_mawrite; /* maximum read revision */ /* from lvid */ time_t udf_time; /* Last time super block is written */ uint32_t udf_mod; /* file system was modified */ uint32_t udf_clean; /* state of the file system */ kmutex_t udf_lock; /* protects contents */ kmutex_t udf_rename_lck; /* lock for udf_rename */ /* * Have them cached here for fast access */ struct pri_vol_desc *udf_pvd; struct log_vol_desc *udf_lvd; struct log_vol_int_desc *udf_lvid; uint32_t udf_mvds_loc; uint32_t udf_mvds_len; uint32_t udf_rvds_loc; uint32_t udf_rvds_len; uint32_t udf_iseq_loc; uint32_t udf_iseq_len; uint16_t udf_fsd_prn; uint32_t udf_fsd_loc; uint32_t udf_fsd_len; uint16_t udf_ricb_prn; uint32_t udf_ricb_loc; uint32_t udf_ricb_len; daddr_t udf_root_blkno; }; #ifndef __lint _NOTE(MUTEX_PROTECTS_DATA(udf_vfs::udf_lock, udf_vfs::udf_fragmented)) _NOTE(MUTEX_PROTECTS_DATA(udf_vfs::udf_lock, udf_vfs::udf_freeblks udf_vfs::udf_totalblks)) _NOTE(MUTEX_PROTECTS_DATA(udf_vfs::udf_lock, udf_vfs::udf_maxuniq udf_vfs::udf_nfiles udf_vfs::udf_ndirs)) _NOTE(MUTEX_PROTECTS_DATA(udf_vfs::udf_lock, udf_vfs::udf_time udf_vfs::udf_mod udf_vfs::udf_clean)) _NOTE(READ_ONLY_DATA(udf_vfs::udf_nmaps udf_vfs::udf_maps)) _NOTE(READ_ONLY_DATA(udf_vfs::udf_mtype udf_vfs::udf_rdclustsz udf_vfs::udf_wrclustsz udf_vfs::udf_maxfsize udf_vfs::udf_maxfbits udf_vfs::udf_lbsize udf_vfs::udf_l2b_shift udf_vfs::udf_lbmask udf_vfs::udf_l2d_shift)) _NOTE(READ_ONLY_DATA(udf_vfs::udf_pvd udf_vfs::udf_lvd udf_vfs::udf_lvid)) _NOTE(READ_ONLY_DATA(udf_vfs::udf_mvds_loc udf_vfs::udf_mvds_len udf_vfs::udf_iseq_loc udf_vfs::udf_iseq_len udf_vfs::udf_fsd_prn udf_vfs::udf_fsd_loc udf_vfs::udf_fsd_len udf_vfs::udf_ricb_prn udf_vfs::udf_ricb_loc udf_vfs::udf_ricb_len udf_vfs::udf_root_blkno)) _NOTE(READ_ONLY_DATA(ud_part::udp_flags ud_part::udp_number ud_part::udp_seqno ud_part::udp_access ud_part::udp_start ud_part::udp_length ud_part::udp_unall_loc ud_part::udp_unall_len ud_part::udp_freed_loc ud_part::udp_freed_len ud_part::udp_nblocks)) _NOTE(MUTEX_PROTECTS_DATA(udf_vfs::udf_lock, ud_part::udp_nfree ud_part::udp_last_alloc ud_part::udp_cache_count ud_part::udp_cache)) #endif /* * udf_mtype */ #define UDF_MT_RO UDP_MT_RO /* ROM */ #define UDF_MT_WO UDP_MT_OW /* WORM */ #define UDF_MT_RW UDP_MT_RW /* RW */ #define UDF_MT_OW UDP_MT_OW /* OW */ /* * udf_flags */ #define UDF_FL_RDONLY 0x0001 /* file system is read only */ #define UDF_FL_RW 0x0002 /* file system is read write */ /* * udf_clean */ #define UDF_DIRTY 0x00 #define UDF_CLEAN 0x01 #define RD_CLUSTSZ(ip) ((ip)->i_udf->udf_rdclustsz) #define WR_CLUSTSZ(ip) ((ip)->i_udf->udf_wrclustsz) /* * Size can be a 64-bit value and therefore we sign extend fs_bmask * to a 64-bit value too so that the higher 32 bits are masked * properly. Note that the type of fs_bmask has to be signed. Otherwise * compiler will set the higher 32 bits as zero and we don't want * this to happen. */ #ifdef UNDEF #define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \ (((size) + (fs)->udf_lbsize - 1) & (offset_t)(fs)->udf_lbmask) #endif #define blkroundup(fs, size) /* calculates roundup(size, fs->fs_bsize) */ \ (((size) + (fs)->udf_lbmask) & (offset_t)(~(fs)->udf_lbmask)) #define blksize(fs) (fs->udf_lbsize) /* * Convert between inode pointers and vnode pointers */ #define VTOI(VP) ((struct ud_inode *)(VP)->v_data) #define ITOV(IP) ((IP)->i_vnode) #define i_vfs i_vnode->v_vfsp struct icb_ext { uint16_t ib_flags; /* Direct Entry will go here */ uint16_t ib_prn; /* partition reference number */ uint32_t ib_block; /* block offset into partition */ uint64_t ib_offset; /* offset into the file bytes */ int32_t ib_count; /* No of bytes in current ext */ uint32_t ib_marker1; /* 0xAAAAAAAA */ uint32_t ib_marker2; /* 0xBBBBBBBB */ }; /* ib_flags */ #define IB_UN_REC 0x1 /* The entry is not allocated */ #define IB_UN_RE_AL 0x2 /* The entry is not recorded */ /* and not unallocated */ #define IB_CON 0x3 /* Continuation entry */ #define IB_MASK 0x3 #define IB_ALLOCATED(flags) \ (((flags) & IB_MASK) != IB_UN_RE_AL) #define EXT_PER_MALLOC 8 struct ud_inode { struct ud_inode *i_forw; struct ud_inode *i_back; struct ud_inode *i_freef; struct ud_inode *i_freeb; struct vnode *i_vnode; /* vnode associated with this inode */ struct vnode *i_devvp; /* vnode for block I/O */ struct udf_vfs *i_udf; /* incore fs associated with inode */ krwlock_t i_rwlock; /* serializes write/setattr requests */ krwlock_t i_contents; /* protects (most of) inode contents */ dev_t i_dev; /* device where inode resides */ u_offset_t i_diroff; /* last loc for fast name lookup */ daddr_t i_icb_lbano; /* Loc of file icb on disk */ uint16_t i_icb_prn; /* partition reference number */ kcondvar_t i_wrcv; /* sleep/wakeup for write throttle */ uint32_t i_flag; uint32_t i_icb_block; int16_t i_astrat; /* ICB strategy */ int16_t i_desc_type; /* Allocation desc type */ int32_t i_ext_count; /* Number of extents allocated */ int32_t i_ext_used; /* Number of extents used */ struct icb_ext *i_ext; /* array of extents */ kmutex_t i_con_lock; struct icb_ext *i_con; int32_t i_con_count; int32_t i_con_used; int32_t i_con_read; uint32_t i_cur_max_ext; vtype_t i_type; /* File type */ uint16_t i_char; /* File characteristics */ uint16_t i_perm; /* File permissions */ uid_t i_uid; /* File owner's uid */ gid_t i_gid; /* File owner's gid */ uint32_t i_nlink; /* number of links to file */ uint32_t i_maxent; /* Max entries that are recorded */ u_offset_t i_size; /* File size in bytes */ uint64_t i_lbr; /* Logical blocks recorded */ uint64_t i_uniqid; /* from the file entry */ timespec32_t i_atime; timespec32_t i_mtime; timespec32_t i_ctime; size_t i_delaylen; /* delayed writes, units=bytes */ offset_t i_delayoff; /* where we started delaying */ offset_t i_nextrio; /* where to start the next clust */ uint64_t i_writes; /* remaining bytes in write q */ kmutex_t i_tlock; /* protects time fields, i_flag */ major_t i_major; minor_t i_minor; uint32_t i_marker1; /* 0xAAAAAAAA */ uint32_t i_seq; /* sequence number attribute */ offset_t i_nextr; /* next byte read offset (read-ahead) */ long i_mapcnt; /* number of mappings of pages */ int *i_map; /* block list for the file */ dev_t i_rdev; /* INCORE rdev from */ uint32_t i_marker2; /* 0xBBBBBBBB */ uint32_t i_data_off; /* Data offset into embedded file */ uint32_t i_max_emb; uint32_t i_marker3; }; #ifndef __lint _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_astrat)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_desc_type)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_ext_count)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_ext_used)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_ext)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_type)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_char)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_perm)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_uid)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_gid)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_nlink)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_size)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_lbr)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_uniqid)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_major)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, ud_inode::i_minor)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_atime)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_mtime)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_ctime)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_delayoff)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_delaylen)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_nextrio)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_writes)) _NOTE(MUTEX_PROTECTS_DATA(ud_inode::i_tlock, ud_inode::i_flag)) _NOTE(RWLOCK_PROTECTS_DATA(ud_inode::i_contents, icb_ext::ib_flags icb_ext::ib_prn icb_ext::ib_block icb_ext::ib_count icb_ext::ib_offset)) #endif /* i_flag */ #define IUPD 0x0001 /* file has been modified */ #define IACC 0x0002 /* inode access time to be updated */ #define IMOD 0x0004 /* inode has been modified */ #define ICHG 0x0008 /* inode has been changed */ #define INOACC 0x0010 /* no access time update in getpage */ #define IMODTIME 0x0020 /* mod time already set */ #define IREF 0x0040 /* inode is being referenced */ #define ISYNC 0x0080 /* do all allocation synchronously */ #define IMODACC 0x0200 /* only access time changed; */ #define IATTCHG 0x0400 /* only size/blocks have changed */ #define IBDWRITE 0x0800 /* the inode has been scheduled for */ /* write operation asynchrously */ /* * i_char * Do not change used by MANDLOCK macro in vnode.h */ #define ISUID VSUID /* set user id on execution */ #define ISGID VSGID /* set group id on execution */ #define ISVTX VSVTX /* save swapped text even after use */ /* * Setuid --S--------- * Setgid -G---------- * SaveTXT T----------- */ /* i_perm */ #define IEXEC 0x0400 /* read, write, execute permissions */ #define IWRITE 0x0800 #define IREAD 0x1000 #define IATTR 0x2000 #define IDELE 0x4000 #define UP_MASK 0x1CE7 #define VA2UD_PERM(perm) \ (((perm) & 0x7) | (((perm) & 0x38) << 2) | (((perm) & 0x1C0) << 4)) #define UD2VA_PERM(perm) \ (((perm) & 0x7) | (((perm) & 0xE0) >> 2) | (((perm) & 0x1C00) >> 4)) /* * Permissions * Other -----------DARWX * Group ------DARWX----- * Owner -DARWX---------- */ #define UD_DPERM2UPERM(dperm) ((((dperm) >> 4) & 0x1C0) | \ (((dperm) >> 2) & 0x38) | \ ((dperm) & 0x7)) #define UD_UPERM2DPERM(uperm) ((((uperm) & 0x1C0) << 4) | \ (((uperm) & 0x38) << 2) | \ ((uperm) & 0x7)) /* specify how the inode info is written in ud_syncip() */ #define I_SYNC 1 /* wait for the inode written to disk */ #define I_DSYNC 2 /* wait for the inode written to disk */ /* only if IATTCHG is set */ #define I_ASYNC 0 /* don't wait for the inode written */ #define UD_HASH_SZ 512 #if ((UD_HASH_SZ & (UD_HASH_SZ - 1)) == 0) #define UD_INOHASH(dev, bno) (hash2ints((int)dev, (int)bno) & UD_HASH_SZ - 1) #else #define UD_INOHASH(dev, bno) (hash2ints((int)dev, (int)bno) % UD_HASH_SZ) #endif union ihead { union ihead *ih_head[2]; struct ud_inode *ih_chain[2]; }; #define IMARK(ip) ud_imark(ip) #define ITIMES_NOLOCK(ip) ud_itimes_nolock(ip) #define ITIMES(ip) { \ mutex_enter(&(ip)->i_tlock); \ ITIMES_NOLOCK(ip); \ mutex_exit(&(ip)->i_tlock); \ } #define ESAME (-1) /* trying to rename linked files (special) */ #define UDF_HOLE (daddr32_t)-1 /* value used when no block allocated */ extern int32_t ud_trace; #define ud_printf(xyz) \ if (ud_trace) { \ cmn_err(CE_NOTE, xyz); \ } #ifndef __lint _NOTE(SCHEME_PROTECTS_DATA("Unshared data", buf dirent64 fid flock64 statvfs64 timespec32 udf_fid uio vattr vfs vnode)) _NOTE(SCHEME_PROTECTS_DATA("Unshared data", file_entry file_id icb_tag indirect_entry log_vol_int_desc long_ad lvid_iu regid short_ad tag tstamp)) _NOTE(LOCK_ORDER(ud_inode::i_rwlock ud_inode::i_contents ud_inode::i_tlock)) #endif /* * udf_vfsops.c */ void ud_update_superblock(struct vfs *); /* * udf_vnops.c */ int32_t ud_rdwri(enum uio_rw, int32_t, struct ud_inode *, caddr_t, int32_t, offset_t, enum uio_seg, int32_t *, struct cred *cr); int32_t ud_putapage(struct vnode *, page_t *, u_offset_t *, size_t *, int32_t, struct cred *); /* * udf_inode.c */ int32_t ud_iget(struct vfs *, uint16_t, uint32_t, struct ud_inode **, struct buf *, struct cred *); void ud_iinactive(struct ud_inode *, struct cred *); void ud_iupdat(struct ud_inode *, int32_t); int32_t ud_itrunc(struct ud_inode *, u_offset_t, int32_t, struct cred *); int32_t ud_iaccess(struct ud_inode *, int32_t, struct cred *, int dolock); int32_t ud_iflush(struct vfs *); void ud_imark(struct ud_inode *); void ud_itimes_nolock(struct ud_inode *); void ud_delcache(struct ud_inode *); void ud_idrop(struct ud_inode *); void ud_init_inodes(void); /* * udf_alloc.c */ int32_t ud_alloc_space(struct vfs *, uint16_t, uint32_t, uint32_t, uint32_t *, uint32_t *, int32_t, int32_t); void ud_free_space(struct vfs *, uint16_t, uint32_t, uint32_t); int32_t ud_ialloc(struct ud_inode *, struct ud_inode **, struct vattr *, struct cred *); void ud_ifree(struct ud_inode *, vtype_t); int32_t ud_freesp(struct vnode *, struct flock64 *, int32_t, struct cred *); int32_t ud_alloc_from_cache(struct udf_vfs *, struct ud_part *, uint32_t *); int32_t ud_release_cache(struct udf_vfs *); /* * udf_subr.c */ void ud_vfs_add(struct udf_vfs *); void ud_vfs_remove(struct udf_vfs *); daddr_t ud_xlate_to_daddr(struct udf_vfs *, uint16_t, uint32_t, int32_t, uint32_t *); int32_t ud_ip_off2bno(struct ud_inode *, uint32_t, uint32_t *); void ud_dtime2utime(struct timespec32 *, struct tstamp const *); void ud_utime2dtime(struct timespec32 const *, struct tstamp *); int32_t ud_syncip(struct ud_inode *, int32_t, int32_t); void ud_update(int32_t); int32_t ud_fbwrite(struct fbuf *, struct ud_inode *); void ud_sbwrite(struct udf_vfs *); int32_t ud_sync_indir(struct ud_inode *); void ud_update_regid(struct regid *); int32_t ud_read_icb_till_off(struct ud_inode *, u_offset_t); void ud_make_tag(struct udf_vfs *, struct tag *, uint16_t, uint32_t, uint16_t); int32_t ud_make_dev_spec_ear(struct dev_spec_ear *, major_t, minor_t); int32_t ud_make_ftimes_ear(struct ftimes_ear *, int32_t, struct timespec32 *); int32_t ud_get_next_fid(struct ud_inode *, struct fbuf **, uint32_t, struct file_id **, uint8_t **, uint8_t *); int32_t ud_verify_tag_and_desc(struct tag *, uint16_t, uint32_t, int32_t, int32_t); uint16_t ud_crc(uint8_t *, int32_t); int32_t ud_compressunicode(int32_t, int32_t, uint16_t *, uint8_t *); uint32_t ud_check_te_unrec(struct udf_vfs *, caddr_t, uint32_t); int32_t ud_compress(int32_t, int32_t *, uint8_t *, uint8_t *); int32_t ud_uncompress(int32_t, int32_t *, uint8_t *, uint8_t *); struct buf *ud_bread(dev_t, daddr_t, long); int ud_sticky_remove_access(struct ud_inode *, struct ud_inode *, struct cred *); /* * udf_dir.c */ int32_t ud_dirlook(struct ud_inode *, char *, struct ud_inode **, struct cred *, int32_t); int32_t ud_direnter(struct ud_inode *, char *, enum de_op, struct ud_inode *, struct ud_inode *, struct vattr *, struct ud_inode **, struct cred *, caller_context_t *); int32_t ud_dirremove(struct ud_inode *, char *, struct ud_inode *, struct vnode *, enum dr_op, struct cred *, caller_context_t *); /* * udf_bmap.c */ int32_t ud_bmap_has_holes(struct ud_inode *); int32_t ud_bmap_write(struct ud_inode *, u_offset_t, int, int32_t, struct cred *); int32_t ud_bmap_read(struct ud_inode *, u_offset_t, daddr_t *, int32_t *); void ud_insert_new_ext(struct ud_inode *, int32_t, struct icb_ext *); int32_t ud_alloc_and_make_ext(struct ud_inode *, int32_t); int32_t ud_create_new_icb(struct ud_inode *); void ud_append_new_ext(struct ud_inode *, uint16_t, u_offset_t, uint32_t, uint16_t, uint32_t); #ifdef __cplusplus } #endif #endif /* _SYS_FS_UDF_INODE_H */