1/* 2 Unix SMB/CIFS implementation. 3 4 POSIX NTVFS backend - structure definitions 5 6 Copyright (C) Andrew Tridgell 2004 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. 20*/ 21 22#ifndef _VFS_POSIX_H_ 23#define _VFS_POSIX_H_ 24 25#include "librpc/gen_ndr/xattr.h" 26#include "system/filesys.h" 27#include "ntvfs/ntvfs.h" 28#include "ntvfs/common/ntvfs_common.h" 29#include "libcli/wbclient/wbclient.h" 30#include "lib/events/events.h" 31 32struct pvfs_wait; 33struct pvfs_oplock; 34 35/* this is the private structure for the posix vfs backend. It is used 36 to hold per-connection (per tree connect) state information */ 37struct pvfs_state { 38 struct ntvfs_module_context *ntvfs; 39 const char *base_directory; 40 struct GUID *base_fs_uuid; 41 42 const char *share_name; 43 uint_t flags; 44 45 struct pvfs_mangle_context *mangle_ctx; 46 47 struct brl_context *brl_context; 48 struct odb_context *odb_context; 49 struct notify_context *notify_context; 50 struct wbc_context *wbc_ctx; 51 52 /* a list of pending async requests. Needed to support 53 ntcancel */ 54 struct pvfs_wait *wait_list; 55 56 /* the sharing violation timeout (nsecs) */ 57 uint_t sharing_violation_delay; 58 59 /* the oplock break timeout (secs) */ 60 uint_t oplock_break_timeout; 61 62 /* the write time update delay (nsecs) */ 63 uint_t writetime_delay; 64 65 /* filesystem attributes (see FS_ATTR_*) */ 66 uint32_t fs_attribs; 67 68 /* if posix:eadb is set, then this gets setup */ 69 struct tdb_wrap *ea_db; 70 71 /* the allocation size rounding */ 72 uint32_t alloc_size_rounding; 73 74 struct { 75 /* the open files as DLINKLIST */ 76 struct pvfs_file *list; 77 } files; 78 79 struct { 80 /* an id tree mapping open search ID to a pvfs_search_state structure */ 81 struct idr_context *idtree; 82 83 /* the open searches as DLINKLIST */ 84 struct pvfs_search_state *list; 85 86 /* how long to keep inactive searches around for */ 87 uint_t inactivity_time; 88 } search; 89 90 /* used to accelerate acl mapping */ 91 struct { 92 const struct dom_sid *creator_owner; 93 const struct dom_sid *creator_group; 94 } sid_cache; 95 96 /* the acl backend */ 97 const struct pvfs_acl_ops *acl_ops; 98 99 /* non-flag share options */ 100 struct { 101 mode_t dir_mask; 102 mode_t force_dir_mode; 103 mode_t create_mask; 104 mode_t force_create_mode; 105 } options; 106}; 107 108/* this is the basic information needed about a file from the filesystem */ 109struct pvfs_dos_fileinfo { 110 NTTIME create_time; 111 NTTIME access_time; 112 NTTIME write_time; 113 NTTIME change_time; 114 uint32_t attrib; 115 uint64_t alloc_size; 116 uint32_t nlink; 117 uint32_t ea_size; 118 uint64_t file_id; 119 uint32_t flags; 120}; 121 122/* 123 this is the structure returned by pvfs_resolve_name(). It holds the posix details of 124 a filename passed by the client to any function 125*/ 126struct pvfs_filename { 127 const char *original_name; 128 char *full_name; 129 const char *stream_name; /* does not include :$DATA suffix */ 130 uint32_t stream_id; /* this uses a hash, so is probabilistic */ 131 bool has_wildcard; 132 bool exists; /* true if the base filename exists */ 133 bool stream_exists; /* true if the stream exists */ 134 struct stat st; 135 struct pvfs_dos_fileinfo dos; 136}; 137 138 139/* open file handle state - encapsulates the posix fd 140 141 Note that this is separated from the pvfs_file structure in order 142 to cope with the openx DENY_DOS semantics where a 2nd DENY_DOS open 143 on the same connection gets the same low level filesystem handle, 144 rather than a new handle 145*/ 146struct pvfs_file_handle { 147 int fd; 148 149 struct pvfs_filename *name; 150 151 /* a unique file key to be used for open file locking */ 152 DATA_BLOB odb_locking_key; 153 154 uint32_t create_options; 155 156 /* this is set by the mode_information level. What does it do? */ 157 uint32_t mode; 158 159 /* yes, we need 2 independent positions ... */ 160 uint64_t seek_offset; 161 uint64_t position; 162 163 bool have_opendb_entry; 164 165 /* 166 * we need to wait for oplock break requests from other processes, 167 * and we need to remember the pvfs_file so we can correctly 168 * forward the oplock break to the client 169 */ 170 struct pvfs_oplock *oplock; 171 172 /* we need this hook back to our parent for lock destruction */ 173 struct pvfs_state *pvfs; 174 175 struct { 176 bool update_triggered; 177 struct tevent_timer *update_event; 178 bool update_on_close; 179 NTTIME close_time; 180 bool update_forced; 181 } write_time; 182 183 /* the open went through to completion */ 184 bool open_completed; 185}; 186 187/* open file state */ 188struct pvfs_file { 189 struct pvfs_file *next, *prev; 190 struct pvfs_file_handle *handle; 191 struct ntvfs_handle *ntvfs; 192 193 struct pvfs_state *pvfs; 194 195 uint32_t impersonation; 196 uint32_t share_access; 197 uint32_t access_mask; 198 199 /* a list of pending locks - used for locking cancel operations */ 200 struct pvfs_pending_lock *pending_list; 201 202 /* a file handle to be used for byte range locking */ 203 struct brl_handle *brl_handle; 204 205 /* a count of active locks - used to avoid calling brl_close on 206 file close */ 207 uint64_t lock_count; 208 209 /* for directories, a buffer of pending notify events */ 210 struct pvfs_notify_buffer *notify_buffer; 211 212 /* for directories, the state of an incomplete SMB2 Find */ 213 struct pvfs_search_state *search; 214}; 215 216/* the state of a search started with pvfs_search_first() */ 217struct pvfs_search_state { 218 struct pvfs_search_state *prev, *next; 219 struct pvfs_state *pvfs; 220 uint16_t handle; 221 off_t current_index; 222 uint16_t search_attrib; 223 uint16_t must_attrib; 224 struct pvfs_dir *dir; 225 time_t last_used; 226 uint_t num_ea_names; 227 struct ea_name *ea_names; 228 struct tevent_timer *te; 229}; 230 231/* flags to pvfs_resolve_name() */ 232#define PVFS_RESOLVE_WILDCARD (1<<0) 233#define PVFS_RESOLVE_STREAMS (1<<1) 234#define PVFS_RESOLVE_NO_OPENDB (1<<2) 235 236/* flags in pvfs->flags */ 237#define PVFS_FLAG_CI_FILESYSTEM (1<<0) /* the filesystem is case insensitive */ 238#define PVFS_FLAG_MAP_ARCHIVE (1<<1) 239#define PVFS_FLAG_MAP_SYSTEM (1<<2) 240#define PVFS_FLAG_MAP_HIDDEN (1<<3) 241#define PVFS_FLAG_READONLY (1<<4) 242#define PVFS_FLAG_STRICT_SYNC (1<<5) 243#define PVFS_FLAG_STRICT_LOCKING (1<<6) 244#define PVFS_FLAG_XATTR_ENABLE (1<<7) 245#define PVFS_FLAG_FAKE_OPLOCKS (1<<8) 246#define PVFS_FLAG_LINUX_AIO (1<<9) 247 248/* forward declare some anonymous structures */ 249struct pvfs_dir; 250 251/* types of notification for pvfs wait events */ 252enum pvfs_wait_notice {PVFS_WAIT_EVENT, PVFS_WAIT_TIMEOUT, PVFS_WAIT_CANCEL}; 253 254/* 255 state of a pending retry 256*/ 257struct pvfs_odb_retry; 258 259#define PVFS_EADB "posix:eadb" 260#define PVFS_XATTR "posix:xattr" 261#define PVFS_FAKE_OPLOCKS "posix:fakeoplocks" 262#define PVFS_SHARE_DELAY "posix:sharedelay" 263#define PVFS_OPLOCK_TIMEOUT "posix:oplocktimeout" 264#define PVFS_WRITETIME_DELAY "posix:writetimeupdatedelay" 265#define PVFS_ALLOCATION_ROUNDING "posix:allocationrounding" 266#define PVFS_SEARCH_INACTIVITY "posix:searchinactivity" 267#define PVFS_ACL "posix:acl" 268#define PVFS_AIO "posix:aio" 269 270#define PVFS_XATTR_DEFAULT true 271#define PVFS_FAKE_OPLOCKS_DEFAULT false 272#define PVFS_SHARE_DELAY_DEFAULT 1000000 /* nsecs */ 273#define PVFS_OPLOCK_TIMEOUT_DEFAULT 30 /* secs */ 274#define PVFS_WRITETIME_DELAY_DEFAULT 2000000 /* nsecs */ 275#define PVFS_ALLOCATION_ROUNDING_DEFAULT 512 276#define PVFS_SEARCH_INACTIVITY_DEFAULT 300 277 278struct pvfs_acl_ops { 279 const char *name; 280 NTSTATUS (*acl_load)(struct pvfs_state *, struct pvfs_filename *, int , TALLOC_CTX *, 281 struct security_descriptor **); 282 NTSTATUS (*acl_save)(struct pvfs_state *, struct pvfs_filename *, int , struct security_descriptor *); 283}; 284 285#include "ntvfs/posix/vfs_posix_proto.h" 286#include "ntvfs/posix/vfs_acl_proto.h" 287 288NTSTATUS pvfs_aio_pread(struct ntvfs_request *req, union smb_read *rd, 289 struct pvfs_file *f, uint32_t maxcnt); 290NTSTATUS pvfs_aio_pwrite(struct ntvfs_request *req, union smb_write *wr, 291 struct pvfs_file *f); 292 293#endif /* _VFS_POSIX_H_ */ 294