mirror of
https://git.proxmox.com/git/mirror_zfs.git
synced 2026-05-22 02:27:36 +03:00
OpenZFS restructuring - move platform specific headers
Move platform specific Linux headers under include/os/linux/. Update the build system accordingly to detect the platform. This lays some of the initial groundwork to supporting building for other platforms. As part of this change it was necessary to create both a user and kernel space sys/simd.h header which can be included in either context. No functional change, the source has been refactored and the relevant #include's updated. Reviewed-by: Jorgen Lundman <lundman@lundman.net> Reviewed-by: Igor Kozhukhov <igor@dilos.org> Signed-off-by: Matthew Macy <mmacy@FreeBSD.org> Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov> Closes #9198
This commit is contained in:
Matthew Macy
committed by
Brian Behlendorf
Brian Behlendorf
parent
d02186ee2b
commit
006e9a4088
@@ -0,0 +1,12 @@
|
||||
KERNEL_H = \
|
||||
$(top_srcdir)/include/os/linux/zfs/sys/policy.h \
|
||||
$(top_srcdir)/include/os/linux/zfs/sys/zfs_ctldir.h \
|
||||
$(top_srcdir)/include/os/linux/zfs/sys/zfs_dir.h \
|
||||
$(top_srcdir)/include/os/linux/zfs/sys/zfs_vfsops.h \
|
||||
$(top_srcdir)/include/os/linux/zfs/sys/zfs_vnops.h \
|
||||
$(top_srcdir)/include/os/linux/zfs/sys/zpl.h
|
||||
|
||||
if CONFIG_KERNEL
|
||||
kerneldir = @prefix@/src/zfs-$(VERSION)/include/sys
|
||||
kernel_HEADERS = $(KERNEL_H)
|
||||
endif
|
||||
@@ -0,0 +1,60 @@
|
||||
/*
|
||||
* 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright 2015, Joyent, Inc. All rights reserved.
|
||||
* Copyright (c) 2016, Lawrence Livermore National Security, LLC.
|
||||
*/
|
||||
|
||||
#ifndef _SYS_POLICY_H
|
||||
#define _SYS_POLICY_H
|
||||
|
||||
#ifdef _KERNEL
|
||||
|
||||
#include <sys/cred.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/xvattr.h>
|
||||
#include <sys/zpl.h>
|
||||
|
||||
int secpolicy_nfs(const cred_t *);
|
||||
int secpolicy_sys_config(const cred_t *, boolean_t);
|
||||
int secpolicy_vnode_access2(const cred_t *, struct inode *,
|
||||
uid_t, mode_t, mode_t);
|
||||
int secpolicy_vnode_any_access(const cred_t *, struct inode *, uid_t);
|
||||
int secpolicy_vnode_chown(const cred_t *, uid_t);
|
||||
int secpolicy_vnode_create_gid(const cred_t *);
|
||||
int secpolicy_vnode_remove(const cred_t *);
|
||||
int secpolicy_vnode_setdac(const cred_t *, uid_t);
|
||||
int secpolicy_vnode_setid_retain(const cred_t *, boolean_t);
|
||||
int secpolicy_vnode_setids_setgids(const cred_t *, gid_t);
|
||||
int secpolicy_zinject(const cred_t *);
|
||||
int secpolicy_zfs(const cred_t *);
|
||||
void secpolicy_setid_clear(vattr_t *, cred_t *);
|
||||
int secpolicy_setid_setsticky_clear(struct inode *, vattr_t *,
|
||||
const vattr_t *, cred_t *);
|
||||
int secpolicy_xvattr(xvattr_t *, uid_t, cred_t *, vtype_t);
|
||||
int secpolicy_vnode_setattr(cred_t *, struct inode *, struct vattr *,
|
||||
const struct vattr *, int, int (void *, int, cred_t *), void *);
|
||||
int secpolicy_basic_link(const cred_t *);
|
||||
|
||||
#endif /* _KERNEL */
|
||||
#endif /* _SYS_POLICY_H */
|
||||
@@ -0,0 +1,103 @@
|
||||
/*
|
||||
* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (C) 2011 Lawrence Livermore National Security, LLC.
|
||||
* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
|
||||
* LLNL-CODE-403049.
|
||||
* Rewritten for Linux by:
|
||||
* Rohan Puri <rohan.puri15@gmail.com>
|
||||
* Brian Behlendorf <behlendorf1@llnl.gov>
|
||||
*/
|
||||
|
||||
#ifndef _ZFS_CTLDIR_H
|
||||
#define _ZFS_CTLDIR_H
|
||||
|
||||
#include <sys/vnode.h>
|
||||
#include <sys/pathname.h>
|
||||
#include <sys/zfs_vfsops.h>
|
||||
#include <sys/zfs_znode.h>
|
||||
|
||||
#define ZFS_CTLDIR_NAME ".zfs"
|
||||
#define ZFS_SNAPDIR_NAME "snapshot"
|
||||
#define ZFS_SHAREDIR_NAME "shares"
|
||||
|
||||
#define zfs_has_ctldir(zdp) \
|
||||
((zdp)->z_id == ZTOZSB(zdp)->z_root && \
|
||||
(ZTOZSB(zdp)->z_ctldir != NULL))
|
||||
#define zfs_show_ctldir(zdp) \
|
||||
(zfs_has_ctldir(zdp) && \
|
||||
(ZTOZSB(zdp)->z_show_ctldir))
|
||||
|
||||
extern int zfs_expire_snapshot;
|
||||
|
||||
/* zfsctl generic functions */
|
||||
extern int zfsctl_create(zfsvfs_t *);
|
||||
extern void zfsctl_destroy(zfsvfs_t *);
|
||||
extern struct inode *zfsctl_root(znode_t *);
|
||||
extern void zfsctl_init(void);
|
||||
extern void zfsctl_fini(void);
|
||||
extern boolean_t zfsctl_is_node(struct inode *ip);
|
||||
extern boolean_t zfsctl_is_snapdir(struct inode *ip);
|
||||
extern int zfsctl_fid(struct inode *ip, fid_t *fidp);
|
||||
|
||||
/* zfsctl '.zfs' functions */
|
||||
extern int zfsctl_root_lookup(struct inode *dip, char *name,
|
||||
struct inode **ipp, int flags, cred_t *cr, int *direntflags,
|
||||
pathname_t *realpnp);
|
||||
|
||||
/* zfsctl '.zfs/snapshot' functions */
|
||||
extern int zfsctl_snapdir_lookup(struct inode *dip, char *name,
|
||||
struct inode **ipp, int flags, cred_t *cr, int *direntflags,
|
||||
pathname_t *realpnp);
|
||||
extern int zfsctl_snapdir_rename(struct inode *sdip, char *sname,
|
||||
struct inode *tdip, char *tname, cred_t *cr, int flags);
|
||||
extern int zfsctl_snapdir_remove(struct inode *dip, char *name, cred_t *cr,
|
||||
int flags);
|
||||
extern int zfsctl_snapdir_mkdir(struct inode *dip, char *dirname, vattr_t *vap,
|
||||
struct inode **ipp, cred_t *cr, int flags);
|
||||
extern int zfsctl_snapshot_mount(struct path *path, int flags);
|
||||
extern int zfsctl_snapshot_unmount(char *snapname, int flags);
|
||||
extern int zfsctl_snapshot_unmount_delay(spa_t *spa, uint64_t objsetid,
|
||||
int delay);
|
||||
extern int zfsctl_snapdir_vget(struct super_block *sb, uint64_t objsetid,
|
||||
int gen, struct inode **ipp);
|
||||
|
||||
/* zfsctl '.zfs/shares' functions */
|
||||
extern int zfsctl_shares_lookup(struct inode *dip, char *name,
|
||||
struct inode **ipp, int flags, cred_t *cr, int *direntflags,
|
||||
pathname_t *realpnp);
|
||||
|
||||
/*
|
||||
* These inodes numbers are reserved for the .zfs control directory.
|
||||
* It is important that they be no larger that 48-bits because only
|
||||
* 6 bytes are reserved in the NFS file handle for the object number.
|
||||
* However, they should be as large as possible to avoid conflicts
|
||||
* with the objects which are assigned monotonically by the dmu.
|
||||
*/
|
||||
#define ZFSCTL_INO_ROOT 0x0000FFFFFFFFFFFFULL
|
||||
#define ZFSCTL_INO_SHARES 0x0000FFFFFFFFFFFEULL
|
||||
#define ZFSCTL_INO_SNAPDIR 0x0000FFFFFFFFFFFDULL
|
||||
#define ZFSCTL_INO_SNAPDIRS 0x0000FFFFFFFFFFFCULL
|
||||
|
||||
#define ZFSCTL_EXPIRE_SNAPSHOT 300
|
||||
|
||||
#endif /* _ZFS_CTLDIR_H */
|
||||
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* 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 2010 Sun Microsystems, Inc. All rights reserved.
|
||||
* Use is subject to license terms.
|
||||
*/
|
||||
|
||||
#ifndef _SYS_FS_ZFS_DIR_H
|
||||
#define _SYS_FS_ZFS_DIR_H
|
||||
|
||||
#include <sys/pathname.h>
|
||||
#include <sys/dmu.h>
|
||||
#include <sys/zfs_znode.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* zfs_dirent_lock() flags */
|
||||
#define ZNEW 0x0001 /* entry should not exist */
|
||||
#define ZEXISTS 0x0002 /* entry should exist */
|
||||
#define ZSHARED 0x0004 /* shared access (zfs_dirlook()) */
|
||||
#define ZXATTR 0x0008 /* we want the xattr dir */
|
||||
#define ZRENAMING 0x0010 /* znode is being renamed */
|
||||
#define ZCILOOK 0x0020 /* case-insensitive lookup requested */
|
||||
#define ZCIEXACT 0x0040 /* c-i requires c-s match (rename) */
|
||||
#define ZHAVELOCK 0x0080 /* z_name_lock is already held */
|
||||
|
||||
/* mknode flags */
|
||||
#define IS_ROOT_NODE 0x01 /* create a root node */
|
||||
#define IS_XATTR 0x02 /* create an extended attribute node */
|
||||
#define IS_TMPFILE 0x04 /* create a tmpfile */
|
||||
|
||||
extern int zfs_dirent_lock(zfs_dirlock_t **, znode_t *, char *, znode_t **,
|
||||
int, int *, pathname_t *);
|
||||
extern void zfs_dirent_unlock(zfs_dirlock_t *);
|
||||
extern int zfs_link_create(zfs_dirlock_t *, znode_t *, dmu_tx_t *, int);
|
||||
extern int zfs_link_destroy(zfs_dirlock_t *, znode_t *, dmu_tx_t *, int,
|
||||
boolean_t *);
|
||||
extern int zfs_dirlook(znode_t *, char *, struct inode **, int, int *,
|
||||
pathname_t *);
|
||||
extern void zfs_mknode(znode_t *, vattr_t *, dmu_tx_t *, cred_t *,
|
||||
uint_t, znode_t **, zfs_acl_ids_t *);
|
||||
extern void zfs_rmnode(znode_t *);
|
||||
extern void zfs_dl_name_switch(zfs_dirlock_t *dl, char *new, char **old);
|
||||
extern boolean_t zfs_dirempty(znode_t *);
|
||||
extern void zfs_unlinked_add(znode_t *, dmu_tx_t *);
|
||||
extern void zfs_unlinked_drain(zfsvfs_t *zfsvfs);
|
||||
extern void zfs_unlinked_drain_stop_wait(zfsvfs_t *zfsvfs);
|
||||
extern int zfs_sticky_remove_access(znode_t *, znode_t *, cred_t *cr);
|
||||
extern int zfs_get_xattrdir(znode_t *, struct inode **, cred_t *, int);
|
||||
extern int zfs_make_xattrdir(znode_t *, vattr_t *, struct inode **, cred_t *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _SYS_FS_ZFS_DIR_H */
|
||||
@@ -0,0 +1,235 @@
|
||||
/*
|
||||
* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2013, 2018 by Delphix. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef _SYS_FS_ZFS_VFSOPS_H
|
||||
#define _SYS_FS_ZFS_VFSOPS_H
|
||||
|
||||
#include <sys/dataset_kstats.h>
|
||||
#include <sys/isa_defs.h>
|
||||
#include <sys/types32.h>
|
||||
#include <sys/list.h>
|
||||
#include <sys/vfs.h>
|
||||
#include <sys/zil.h>
|
||||
#include <sys/sa.h>
|
||||
#include <sys/rrwlock.h>
|
||||
#include <sys/dsl_dataset.h>
|
||||
#include <sys/zfs_ioctl.h>
|
||||
#include <sys/objlist.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct zfsvfs zfsvfs_t;
|
||||
struct znode;
|
||||
|
||||
/*
|
||||
* This structure emulates the vfs_t from other platforms. It's purpose
|
||||
* is to facilitate the handling of mount options and minimize structural
|
||||
* differences between the platforms.
|
||||
*/
|
||||
typedef struct vfs {
|
||||
struct zfsvfs *vfs_data;
|
||||
char *vfs_mntpoint; /* Primary mount point */
|
||||
uint64_t vfs_xattr;
|
||||
boolean_t vfs_readonly;
|
||||
boolean_t vfs_do_readonly;
|
||||
boolean_t vfs_setuid;
|
||||
boolean_t vfs_do_setuid;
|
||||
boolean_t vfs_exec;
|
||||
boolean_t vfs_do_exec;
|
||||
boolean_t vfs_devices;
|
||||
boolean_t vfs_do_devices;
|
||||
boolean_t vfs_do_xattr;
|
||||
boolean_t vfs_atime;
|
||||
boolean_t vfs_do_atime;
|
||||
boolean_t vfs_relatime;
|
||||
boolean_t vfs_do_relatime;
|
||||
boolean_t vfs_nbmand;
|
||||
boolean_t vfs_do_nbmand;
|
||||
} vfs_t;
|
||||
|
||||
typedef struct zfs_mnt {
|
||||
const char *mnt_osname; /* Objset name */
|
||||
char *mnt_data; /* Raw mount options */
|
||||
} zfs_mnt_t;
|
||||
|
||||
struct zfsvfs {
|
||||
vfs_t *z_vfs; /* generic fs struct */
|
||||
struct super_block *z_sb; /* generic super_block */
|
||||
struct zfsvfs *z_parent; /* parent fs */
|
||||
objset_t *z_os; /* objset reference */
|
||||
uint64_t z_flags; /* super_block flags */
|
||||
uint64_t z_root; /* id of root znode */
|
||||
uint64_t z_unlinkedobj; /* id of unlinked zapobj */
|
||||
uint64_t z_max_blksz; /* maximum block size for files */
|
||||
uint64_t z_fuid_obj; /* fuid table object number */
|
||||
uint64_t z_fuid_size; /* fuid table size */
|
||||
avl_tree_t z_fuid_idx; /* fuid tree keyed by index */
|
||||
avl_tree_t z_fuid_domain; /* fuid tree keyed by domain */
|
||||
krwlock_t z_fuid_lock; /* fuid lock */
|
||||
boolean_t z_fuid_loaded; /* fuid tables are loaded */
|
||||
boolean_t z_fuid_dirty; /* need to sync fuid table ? */
|
||||
struct zfs_fuid_info *z_fuid_replay; /* fuid info for replay */
|
||||
zilog_t *z_log; /* intent log pointer */
|
||||
uint_t z_acl_inherit; /* acl inheritance behavior */
|
||||
uint_t z_acl_type; /* type of ACL usable on this FS */
|
||||
zfs_case_t z_case; /* case-sense */
|
||||
boolean_t z_utf8; /* utf8-only */
|
||||
int z_norm; /* normalization flags */
|
||||
boolean_t z_relatime; /* enable relatime mount option */
|
||||
boolean_t z_unmounted; /* unmounted */
|
||||
rrmlock_t z_teardown_lock;
|
||||
krwlock_t z_teardown_inactive_lock;
|
||||
list_t z_all_znodes; /* all znodes in the fs */
|
||||
uint64_t z_nr_znodes; /* number of znodes in the fs */
|
||||
unsigned long z_rollback_time; /* last online rollback time */
|
||||
unsigned long z_snap_defer_time; /* last snapshot unmount deferral */
|
||||
kmutex_t z_znodes_lock; /* lock for z_all_znodes */
|
||||
arc_prune_t *z_arc_prune; /* called by ARC to prune caches */
|
||||
struct inode *z_ctldir; /* .zfs directory inode */
|
||||
boolean_t z_show_ctldir; /* expose .zfs in the root dir */
|
||||
boolean_t z_issnap; /* true if this is a snapshot */
|
||||
boolean_t z_vscan; /* virus scan on/off */
|
||||
boolean_t z_use_fuids; /* version allows fuids */
|
||||
boolean_t z_replay; /* set during ZIL replay */
|
||||
boolean_t z_use_sa; /* version allow system attributes */
|
||||
boolean_t z_xattr_sa; /* allow xattrs to be stores as SA */
|
||||
boolean_t z_draining; /* is true when drain is active */
|
||||
boolean_t z_drain_cancel; /* signal the unlinked drain to stop */
|
||||
uint64_t z_version; /* ZPL version */
|
||||
uint64_t z_shares_dir; /* hidden shares dir */
|
||||
dataset_kstats_t z_kstat; /* fs kstats */
|
||||
kmutex_t z_lock;
|
||||
uint64_t z_userquota_obj;
|
||||
uint64_t z_groupquota_obj;
|
||||
uint64_t z_userobjquota_obj;
|
||||
uint64_t z_groupobjquota_obj;
|
||||
uint64_t z_projectquota_obj;
|
||||
uint64_t z_projectobjquota_obj;
|
||||
uint64_t z_replay_eof; /* New end of file - replay only */
|
||||
sa_attr_type_t *z_attr_table; /* SA attr mapping->id */
|
||||
uint64_t z_hold_size; /* znode hold array size */
|
||||
avl_tree_t *z_hold_trees; /* znode hold trees */
|
||||
kmutex_t *z_hold_locks; /* znode hold locks */
|
||||
taskqid_t z_drain_task; /* task id for the unlink drain task */
|
||||
};
|
||||
|
||||
#define ZSB_XATTR 0x0001 /* Enable user xattrs */
|
||||
|
||||
/*
|
||||
* Allow a maximum number of links. While ZFS does not internally limit
|
||||
* this the inode->i_nlink member is defined as an unsigned int. To be
|
||||
* safe we use 2^31-1 as the limit.
|
||||
*/
|
||||
#define ZFS_LINK_MAX ((1U << 31) - 1U)
|
||||
|
||||
/*
|
||||
* Normal filesystems (those not under .zfs/snapshot) have a total
|
||||
* file ID size limited to 12 bytes (including the length field) due to
|
||||
* NFSv2 protocol's limitation of 32 bytes for a filehandle. For historical
|
||||
* reasons, this same limit is being imposed by the Solaris NFSv3 implementation
|
||||
* (although the NFSv3 protocol actually permits a maximum of 64 bytes). It
|
||||
* is not possible to expand beyond 12 bytes without abandoning support
|
||||
* of NFSv2.
|
||||
*
|
||||
* For normal filesystems, we partition up the available space as follows:
|
||||
* 2 bytes fid length (required)
|
||||
* 6 bytes object number (48 bits)
|
||||
* 4 bytes generation number (32 bits)
|
||||
*
|
||||
* We reserve only 48 bits for the object number, as this is the limit
|
||||
* currently defined and imposed by the DMU.
|
||||
*/
|
||||
typedef struct zfid_short {
|
||||
uint16_t zf_len;
|
||||
uint8_t zf_object[6]; /* obj[i] = obj >> (8 * i) */
|
||||
uint8_t zf_gen[4]; /* gen[i] = gen >> (8 * i) */
|
||||
} zfid_short_t;
|
||||
|
||||
/*
|
||||
* Filesystems under .zfs/snapshot have a total file ID size of 22 bytes
|
||||
* (including the length field). This makes files under .zfs/snapshot
|
||||
* accessible by NFSv3 and NFSv4, but not NFSv2.
|
||||
*
|
||||
* For files under .zfs/snapshot, we partition up the available space
|
||||
* as follows:
|
||||
* 2 bytes fid length (required)
|
||||
* 6 bytes object number (48 bits)
|
||||
* 4 bytes generation number (32 bits)
|
||||
* 6 bytes objset id (48 bits)
|
||||
* 4 bytes currently just zero (32 bits)
|
||||
*
|
||||
* We reserve only 48 bits for the object number and objset id, as these are
|
||||
* the limits currently defined and imposed by the DMU.
|
||||
*/
|
||||
typedef struct zfid_long {
|
||||
zfid_short_t z_fid;
|
||||
uint8_t zf_setid[6]; /* obj[i] = obj >> (8 * i) */
|
||||
uint8_t zf_setgen[4]; /* gen[i] = gen >> (8 * i) */
|
||||
} zfid_long_t;
|
||||
|
||||
#define SHORT_FID_LEN (sizeof (zfid_short_t) - sizeof (uint16_t))
|
||||
#define LONG_FID_LEN (sizeof (zfid_long_t) - sizeof (uint16_t))
|
||||
|
||||
extern uint_t zfs_fsyncer_key;
|
||||
|
||||
extern int zfs_suspend_fs(zfsvfs_t *zfsvfs);
|
||||
extern int zfs_resume_fs(zfsvfs_t *zfsvfs, struct dsl_dataset *ds);
|
||||
extern int zfs_end_fs(zfsvfs_t *zfsvfs, struct dsl_dataset *ds);
|
||||
extern int zfs_userspace_one(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
|
||||
const char *domain, uint64_t rid, uint64_t *valuep);
|
||||
extern int zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
|
||||
uint64_t *cookiep, void *vbuf, uint64_t *bufsizep);
|
||||
extern int zfs_set_userquota(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
|
||||
const char *domain, uint64_t rid, uint64_t quota);
|
||||
extern boolean_t zfs_id_overblockquota(zfsvfs_t *zfsvfs, uint64_t usedobj,
|
||||
uint64_t id);
|
||||
extern boolean_t zfs_id_overobjquota(zfsvfs_t *zfsvfs, uint64_t usedobj,
|
||||
uint64_t id);
|
||||
extern boolean_t zfs_id_overquota(zfsvfs_t *zfsvfs, uint64_t usedobj,
|
||||
uint64_t id);
|
||||
extern int zfs_set_version(zfsvfs_t *zfsvfs, uint64_t newvers);
|
||||
extern int zfsvfs_create(const char *name, boolean_t readony, zfsvfs_t **zfvp);
|
||||
extern int zfsvfs_create_impl(zfsvfs_t **zfvp, zfsvfs_t *zfsvfs, objset_t *os);
|
||||
extern void zfsvfs_free(zfsvfs_t *zfsvfs);
|
||||
extern int zfs_check_global_label(const char *dsname, const char *hexsl);
|
||||
extern objlist_t *zfs_get_deleteq(objset_t *os);
|
||||
|
||||
extern boolean_t zfs_is_readonly(zfsvfs_t *zfsvfs);
|
||||
extern int zfs_domount(struct super_block *sb, zfs_mnt_t *zm, int silent);
|
||||
extern void zfs_preumount(struct super_block *sb);
|
||||
extern int zfs_umount(struct super_block *sb);
|
||||
extern int zfs_remount(struct super_block *sb, int *flags, zfs_mnt_t *zm);
|
||||
extern int zfs_statvfs(struct dentry *dentry, struct kstatfs *statp);
|
||||
extern int zfs_vget(struct super_block *sb, struct inode **ipp, fid_t *fidp);
|
||||
extern int zfs_prune(struct super_block *sb, unsigned long nr_to_scan,
|
||||
int *objects);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _SYS_FS_ZFS_VFSOPS_H */
|
||||
@@ -0,0 +1,89 @@
|
||||
/*
|
||||
* 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) 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef _SYS_FS_ZFS_VNOPS_H
|
||||
#define _SYS_FS_ZFS_VNOPS_H
|
||||
|
||||
#include <sys/vnode.h>
|
||||
#include <sys/xvattr.h>
|
||||
#include <sys/uio.h>
|
||||
#include <sys/cred.h>
|
||||
#include <sys/fcntl.h>
|
||||
#include <sys/pathname.h>
|
||||
#include <sys/zpl.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern int zfs_open(struct inode *ip, int mode, int flag, cred_t *cr);
|
||||
extern int zfs_close(struct inode *ip, int flag, cred_t *cr);
|
||||
extern int zfs_holey(struct inode *ip, int cmd, loff_t *off);
|
||||
extern int zfs_read(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr);
|
||||
extern int zfs_write(struct inode *ip, uio_t *uio, int ioflag, cred_t *cr);
|
||||
extern int zfs_access(struct inode *ip, int mode, int flag, cred_t *cr);
|
||||
extern int zfs_lookup(struct inode *dip, char *nm, struct inode **ipp,
|
||||
int flags, cred_t *cr, int *direntflags, pathname_t *realpnp);
|
||||
extern int zfs_create(struct inode *dip, char *name, vattr_t *vap, int excl,
|
||||
int mode, struct inode **ipp, cred_t *cr, int flag, vsecattr_t *vsecp);
|
||||
extern int zfs_tmpfile(struct inode *dip, vattr_t *vap, int excl,
|
||||
int mode, struct inode **ipp, cred_t *cr, int flag, vsecattr_t *vsecp);
|
||||
extern int zfs_remove(struct inode *dip, char *name, cred_t *cr, int flags);
|
||||
extern int zfs_mkdir(struct inode *dip, char *dirname, vattr_t *vap,
|
||||
struct inode **ipp, cred_t *cr, int flags, vsecattr_t *vsecp);
|
||||
extern int zfs_rmdir(struct inode *dip, char *name, struct inode *cwd,
|
||||
cred_t *cr, int flags);
|
||||
extern int zfs_readdir(struct inode *ip, zpl_dir_context_t *ctx, cred_t *cr);
|
||||
extern int zfs_fsync(struct inode *ip, int syncflag, cred_t *cr);
|
||||
extern int zfs_getattr(struct inode *ip, vattr_t *vap, int flag, cred_t *cr);
|
||||
extern int zfs_getattr_fast(struct inode *ip, struct kstat *sp);
|
||||
extern int zfs_setattr(struct inode *ip, vattr_t *vap, int flag, cred_t *cr);
|
||||
extern int zfs_rename(struct inode *sdip, char *snm, struct inode *tdip,
|
||||
char *tnm, cred_t *cr, int flags);
|
||||
extern int zfs_symlink(struct inode *dip, char *name, vattr_t *vap,
|
||||
char *link, struct inode **ipp, cred_t *cr, int flags);
|
||||
extern int zfs_readlink(struct inode *ip, uio_t *uio, cred_t *cr);
|
||||
extern int zfs_link(struct inode *tdip, struct inode *sip,
|
||||
char *name, cred_t *cr, int flags);
|
||||
extern void zfs_inactive(struct inode *ip);
|
||||
extern int zfs_space(struct inode *ip, int cmd, flock64_t *bfp, int flag,
|
||||
offset_t offset, cred_t *cr);
|
||||
extern int zfs_fid(struct inode *ip, fid_t *fidp);
|
||||
extern int zfs_getsecattr(struct inode *ip, vsecattr_t *vsecp, int flag,
|
||||
cred_t *cr);
|
||||
extern int zfs_setsecattr(struct inode *ip, vsecattr_t *vsecp, int flag,
|
||||
cred_t *cr);
|
||||
extern int zfs_getpage(struct inode *ip, struct page *pl[], int nr_pages);
|
||||
extern int zfs_putpage(struct inode *ip, struct page *pp,
|
||||
struct writeback_control *wbc);
|
||||
extern int zfs_dirty_inode(struct inode *ip, int flags);
|
||||
extern int zfs_map(struct inode *ip, offset_t off, caddr_t *addrp,
|
||||
size_t len, unsigned long vm_flags);
|
||||
extern void zfs_iput_async(struct inode *ip);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _SYS_FS_ZFS_VNOPS_H */
|
||||
@@ -0,0 +1,200 @@
|
||||
/*
|
||||
* 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) 2011, Lawrence Livermore National Security, LLC.
|
||||
*/
|
||||
|
||||
#ifndef _SYS_ZPL_H
|
||||
#define _SYS_ZPL_H
|
||||
|
||||
#include <sys/mntent.h>
|
||||
#include <sys/vfs.h>
|
||||
#include <linux/aio.h>
|
||||
#include <linux/dcache_compat.h>
|
||||
#include <linux/exportfs.h>
|
||||
#include <linux/falloc.h>
|
||||
#include <linux/parser.h>
|
||||
#include <linux/task_io_accounting_ops.h>
|
||||
#include <linux/vfs_compat.h>
|
||||
#include <linux/writeback.h>
|
||||
#include <linux/xattr_compat.h>
|
||||
|
||||
/* zpl_inode.c */
|
||||
extern void zpl_vap_init(vattr_t *vap, struct inode *dir,
|
||||
zpl_umode_t mode, cred_t *cr);
|
||||
|
||||
extern const struct inode_operations zpl_inode_operations;
|
||||
extern const struct inode_operations zpl_dir_inode_operations;
|
||||
extern const struct inode_operations zpl_symlink_inode_operations;
|
||||
extern const struct inode_operations zpl_special_inode_operations;
|
||||
extern dentry_operations_t zpl_dentry_operations;
|
||||
|
||||
/* zpl_file.c */
|
||||
extern ssize_t zpl_read_common(struct inode *ip, const char *buf,
|
||||
size_t len, loff_t *ppos, uio_seg_t segment, int flags,
|
||||
cred_t *cr);
|
||||
extern ssize_t zpl_write_common(struct inode *ip, const char *buf,
|
||||
size_t len, loff_t *ppos, uio_seg_t segment, int flags,
|
||||
cred_t *cr);
|
||||
#if defined(HAVE_FILE_FALLOCATE) || defined(HAVE_INODE_FALLOCATE)
|
||||
extern long zpl_fallocate_common(struct inode *ip, int mode,
|
||||
loff_t offset, loff_t len);
|
||||
#endif /* defined(HAVE_FILE_FALLOCATE) || defined(HAVE_INODE_FALLOCATE) */
|
||||
|
||||
extern const struct address_space_operations zpl_address_space_operations;
|
||||
extern const struct file_operations zpl_file_operations;
|
||||
extern const struct file_operations zpl_dir_file_operations;
|
||||
|
||||
/* zpl_super.c */
|
||||
extern void zpl_prune_sb(int64_t nr_to_scan, void *arg);
|
||||
|
||||
extern const struct super_operations zpl_super_operations;
|
||||
extern const struct export_operations zpl_export_operations;
|
||||
extern struct file_system_type zpl_fs_type;
|
||||
|
||||
/* zpl_xattr.c */
|
||||
extern ssize_t zpl_xattr_list(struct dentry *dentry, char *buf, size_t size);
|
||||
extern int zpl_xattr_security_init(struct inode *ip, struct inode *dip,
|
||||
const struct qstr *qstr);
|
||||
#if defined(CONFIG_FS_POSIX_ACL)
|
||||
extern int zpl_set_acl(struct inode *ip, struct posix_acl *acl, int type);
|
||||
extern struct posix_acl *zpl_get_acl(struct inode *ip, int type);
|
||||
#if !defined(HAVE_GET_ACL)
|
||||
#if defined(HAVE_CHECK_ACL_WITH_FLAGS)
|
||||
extern int zpl_check_acl(struct inode *inode, int mask, unsigned int flags);
|
||||
#elif defined(HAVE_CHECK_ACL)
|
||||
extern int zpl_check_acl(struct inode *inode, int mask);
|
||||
#elif defined(HAVE_PERMISSION_WITH_NAMEIDATA)
|
||||
extern int zpl_permission(struct inode *ip, int mask, struct nameidata *nd);
|
||||
#elif defined(HAVE_PERMISSION)
|
||||
extern int zpl_permission(struct inode *ip, int mask);
|
||||
#endif /* HAVE_CHECK_ACL | HAVE_PERMISSION */
|
||||
#endif /* HAVE_GET_ACL */
|
||||
|
||||
extern int zpl_init_acl(struct inode *ip, struct inode *dir);
|
||||
extern int zpl_chmod_acl(struct inode *ip);
|
||||
#else
|
||||
static inline int
|
||||
zpl_init_acl(struct inode *ip, struct inode *dir)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
|
||||
static inline int
|
||||
zpl_chmod_acl(struct inode *ip)
|
||||
{
|
||||
return (0);
|
||||
}
|
||||
#endif /* CONFIG_FS_POSIX_ACL */
|
||||
|
||||
extern xattr_handler_t *zpl_xattr_handlers[];
|
||||
|
||||
/* zpl_ctldir.c */
|
||||
extern const struct file_operations zpl_fops_root;
|
||||
extern const struct inode_operations zpl_ops_root;
|
||||
|
||||
extern const struct file_operations zpl_fops_snapdir;
|
||||
extern const struct inode_operations zpl_ops_snapdir;
|
||||
#ifdef HAVE_AUTOMOUNT
|
||||
extern const struct dentry_operations zpl_dops_snapdirs;
|
||||
#else
|
||||
extern const struct inode_operations zpl_ops_snapdirs;
|
||||
#endif /* HAVE_AUTOMOUNT */
|
||||
|
||||
extern const struct file_operations zpl_fops_shares;
|
||||
extern const struct inode_operations zpl_ops_shares;
|
||||
|
||||
#if defined(HAVE_VFS_ITERATE) || defined(HAVE_VFS_ITERATE_SHARED)
|
||||
|
||||
#define ZPL_DIR_CONTEXT_INIT(_dirent, _actor, _pos) { \
|
||||
.actor = _actor, \
|
||||
.pos = _pos, \
|
||||
}
|
||||
|
||||
typedef struct dir_context zpl_dir_context_t;
|
||||
|
||||
#define zpl_dir_emit dir_emit
|
||||
#define zpl_dir_emit_dot dir_emit_dot
|
||||
#define zpl_dir_emit_dotdot dir_emit_dotdot
|
||||
#define zpl_dir_emit_dots dir_emit_dots
|
||||
|
||||
#else
|
||||
|
||||
typedef struct zpl_dir_context {
|
||||
void *dirent;
|
||||
const filldir_t actor;
|
||||
loff_t pos;
|
||||
} zpl_dir_context_t;
|
||||
|
||||
#define ZPL_DIR_CONTEXT_INIT(_dirent, _actor, _pos) { \
|
||||
.dirent = _dirent, \
|
||||
.actor = _actor, \
|
||||
.pos = _pos, \
|
||||
}
|
||||
|
||||
static inline bool
|
||||
zpl_dir_emit(zpl_dir_context_t *ctx, const char *name, int namelen,
|
||||
uint64_t ino, unsigned type)
|
||||
{
|
||||
return (!ctx->actor(ctx->dirent, name, namelen, ctx->pos, ino, type));
|
||||
}
|
||||
|
||||
static inline bool
|
||||
zpl_dir_emit_dot(struct file *file, zpl_dir_context_t *ctx)
|
||||
{
|
||||
return (ctx->actor(ctx->dirent, ".", 1, ctx->pos,
|
||||
file_inode(file)->i_ino, DT_DIR) == 0);
|
||||
}
|
||||
|
||||
static inline bool
|
||||
zpl_dir_emit_dotdot(struct file *file, zpl_dir_context_t *ctx)
|
||||
{
|
||||
return (ctx->actor(ctx->dirent, "..", 2, ctx->pos,
|
||||
parent_ino(file_dentry(file)), DT_DIR) == 0);
|
||||
}
|
||||
|
||||
static inline bool
|
||||
zpl_dir_emit_dots(struct file *file, zpl_dir_context_t *ctx)
|
||||
{
|
||||
if (ctx->pos == 0) {
|
||||
if (!zpl_dir_emit_dot(file, ctx))
|
||||
return (false);
|
||||
ctx->pos = 1;
|
||||
}
|
||||
if (ctx->pos == 1) {
|
||||
if (!zpl_dir_emit_dotdot(file, ctx))
|
||||
return (false);
|
||||
ctx->pos = 2;
|
||||
}
|
||||
return (true);
|
||||
}
|
||||
#endif /* HAVE_VFS_ITERATE */
|
||||
|
||||
/*
|
||||
* Linux 4.18, inode times converted from timespec to timespec64.
|
||||
*/
|
||||
#if defined(HAVE_INODE_TIMESPEC64_TIMES)
|
||||
#define zpl_inode_timespec_trunc(ts, gran) timespec64_trunc(ts, gran)
|
||||
#else
|
||||
#define zpl_inode_timespec_trunc(ts, gran) timespec_trunc(ts, gran)
|
||||
#endif
|
||||
|
||||
#endif /* _SYS_ZPL_H */
|
||||
Reference in New Issue
Block a user