diff options
Diffstat (limited to 'usr/src/uts/common/sys/fs/udf_inode.h')
| -rw-r--r-- | usr/src/uts/common/sys/fs/udf_inode.h | 738 |
1 files changed, 738 insertions, 0 deletions
diff --git a/usr/src/uts/common/sys/fs/udf_inode.h b/usr/src/uts/common/sys/fs/udf_inode.h new file mode 100644 index 0000000000..6a2b3e83e1 --- /dev/null +++ b/usr/src/uts/common/sys/fs/udf_inode.h @@ -0,0 +1,738 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (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 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ +/* All Rights Reserved */ + +#ifndef _SYS_FS_UDF_INODE_H +#define _SYS_FS_UDF_INODE_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <sys/note.h> + +#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 *); +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 *); +int32_t ud_dirremove(struct ud_inode *, + char *, struct ud_inode *, struct vnode *, + enum dr_op, struct cred *); + + +/* + * 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 */ |