sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

Merge branch 'v4-0-test' of ssh://git.samba.org/data/git/samba into v4-0-gmake3

Browse Source 
(This used to be commit ac27a1451d)
This commit is contained in:
Jelmer Vernooij 2008-03-07 23:02:36 +01:00
commit 87abb775ce
6 changed files with 141 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
source4/cluster/ctdb/opendb_ctdb.c
View File

@ -261,6 +261,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
return NT_STATUS_OK;
}
#if 0
/*
send an oplock break to a client
*/
@ -271,6 +272,7 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_ent
return messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, e->server,
MSG_NTVFS_OPLOCK_BREAK, e->file_handle);
}
#endif
/*
register an open file in the open files database. This implements the share_access
@ -281,104 +283,16 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb, struct opendb_ent
*/
static NTSTATUS odb_ctdb_open_file(struct odb_lock *lck,
void *file_handle, const char *path,
uint32_t stream_id, uint32_t share_access,
uint32_t access_mask, bool delete_on_close,
uint32_t open_disposition, bool break_to_none,
bool allow_level_II_oplock,
uint32_t oplock_level, uint32_t *oplock_granted)
{
struct odb_context *odb = lck->odb;
struct opendb_entry e;
int i;
struct opendb_file file;
NTSTATUS status;
if (odb->oplocks == false) {
oplock_level = OPLOCK_NONE;
}
status = odb_pull_record(lck, &file);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
/* initialise a blank structure */
ZERO_STRUCT(file);
file.path = path;
} else {
NT_STATUS_NOT_OK_RETURN(status);
}
/* see if it conflicts */
e.server = odb->ntvfs_ctx->server_id;
e.file_handle = file_handle;
e.stream_id = stream_id;
e.share_access = share_access;
e.access_mask = access_mask;
e.delete_on_close = delete_on_close;
e.oplock_level = OPLOCK_NONE;
/* see if anyone has an oplock, which we need to break */
for (i=0;i<file.num_entries;i++) {
if (file.entries[i].oplock_level == OPLOCK_BATCH) {
/* a batch oplock caches close calls, which
means the client application might have
already closed the file. We have to allow
this close to propogate by sending a oplock
break request and suspending this call
until the break is acknowledged or the file
is closed */
odb_oplock_break_send(odb, &file.entries[i]);
return NT_STATUS_OPLOCK_NOT_GRANTED;
}
}
if (file.delete_on_close ||
(file.num_entries != 0 && delete_on_close)) {
/* while delete on close is set, no new opens are allowed */
return NT_STATUS_DELETE_PENDING;
}
/* check for sharing violations */
for (i=0;i<file.num_entries;i++) {
status = share_conflict(&file.entries[i], &e);
NT_STATUS_NOT_OK_RETURN(status);
}
/* we now know the open could succeed, but we need to check
for any exclusive oplocks. We can't grant a second open
till these are broken. Note that we check for batch oplocks
before checking for sharing violations, and check for
exclusive oplocks afterwards. */
for (i=0;i<file.num_entries;i++) {
if (file.entries[i].oplock_level == OPLOCK_EXCLUSIVE) {
odb_oplock_break_send(odb, &file.entries[i]);
return NT_STATUS_OPLOCK_NOT_GRANTED;
}
}
/*
possibly grant an exclusive or batch oplock if this is the only client
with the file open. We don't yet grant levelII oplocks.
*/
if (oplock_granted != NULL) {
if ((oplock_level == OPLOCK_BATCH ||
oplock_level == OPLOCK_EXCLUSIVE) &&
file.num_entries == 0) {
(*oplock_granted) = oplock_level;
} else {
(*oplock_granted) = OPLOCK_NONE;
}
e.oplock_level = (*oplock_granted);
}
/* it doesn't conflict, so add it to the end */
file.entries = talloc_realloc(lck, file.entries, struct opendb_entry,
file.num_entries+1);
NT_STATUS_HAVE_NO_MEMORY(file.entries);
file.entries[file.num_entries] = e;
file.num_entries++;
return odb_push_record(lck, &file);
* as this file will went away and isn't used yet,
* copy the implementation from the tdb backend
* --metze
*/
return NT_STATUS_FOOBAR;
}

6
source4/ntvfs/cifs/vfs_cifs.c
View File

@ -207,7 +207,11 @@ static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs,
io.in.service = remote_share;
io.in.service_type = "?????";
lp_smbcli_options(ntvfs->ctx->lp_ctx, &io.in.options);
if (!(ntvfs->ctx->client_caps & NTVFS_CLIENT_CAP_LEVEL_II_OPLOCKS)) {
io.in.options.use_level2_oplocks = false;
}
creq = smb_composite_connect_send(&io, private,
lp_resolve_context(ntvfs->ctx->lp_ctx),
ntvfs->ctx->event_ctx);

14
source4/ntvfs/common/opendb.c
View File

@ -87,23 +87,21 @@ _PUBLIC_ DATA_BLOB odb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
}
/*
register an open file in the open files database. This implements the share_access
rules
register an open file in the open files database.
The share_access rules are implemented by odb_can_open()
and it's needed to call odb_can_open() before
odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
Note that the path is only used by the delete on close logic, not
for comparing with other filenames
*/
_PUBLIC_ NTSTATUS odb_open_file(struct odb_lock *lck,
void *file_handle, const char *path,
uint32_t stream_id, uint32_t share_access,
uint32_t access_mask, bool delete_on_close,
uint32_t open_disposition, bool break_to_none,
bool allow_level_II_oplock,
uint32_t oplock_level, uint32_t *oplock_granted)
{
return ops->odb_open_file(lck, file_handle, path, stream_id, share_access,
access_mask, delete_on_close, open_disposition,
break_to_none, allow_level_II_oplock,
return ops->odb_open_file(lck, file_handle, path,
allow_level_II_oplock,
oplock_level, oplock_granted);
}

3
source4/ntvfs/common/opendb.h
View File

@ -27,9 +27,6 @@ struct opendb_ops {
DATA_BLOB (*odb_get_key)(TALLOC_CTX *mem_ctx, struct odb_lock *lck);
NTSTATUS (*odb_open_file)(struct odb_lock *lck,
void *file_handle, const char *path,
uint32_t stream_id, uint32_t share_access,
uint32_t access_mask, bool delete_on_close,
uint32_t open_disposition, bool break_to_none,
bool allow_level_II_oplock,
uint32_t oplock_level, uint32_t *oplock_granted);
NTSTATUS (*odb_open_file_pending)(struct odb_lock *lck, void *private);

133
source4/ntvfs/common/opendb_tdb.c
View File

@ -63,6 +63,11 @@ struct odb_context {
struct odb_lock {
struct odb_context *odb;
TDB_DATA key;
struct {
struct opendb_entry *e;
bool attrs_only;
} can_open;
};
/*
@ -130,6 +135,8 @@ static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
return NULL;
}
ZERO_STRUCT(lck->can_open);
talloc_set_destructor(lck, odb_lock_destructor);
return lck;
@ -263,7 +270,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
/*
send an oplock break to a client
*/
static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
struct opendb_entry *e,
uint8_t level)
{
@ -280,7 +287,7 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
blob = data_blob_const(&op_break, sizeof(op_break));
status = messaging_send(odb->ntvfs_ctx->msg_ctx, e->server,
status = messaging_send(msg_ctx, e->server,
MSG_NTVFS_OPLOCK_BREAK, &blob);
NT_STATUS_NOT_OK_RETURN(status);
@ -348,7 +355,8 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
!file->entries[i].allow_level_II_oplock) {
oplock_return = OPLOCK_BREAK_TO_NONE;
}
odb_oplock_break_send(odb, &file->entries[i],
odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
&file->entries[i],
oplock_return);
return NT_STATUS_OPLOCK_NOT_GRANTED;
}
@ -396,7 +404,8 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
!file->entries[i].allow_level_II_oplock) {
oplock_return = OPLOCK_BREAK_TO_NONE;
}
odb_oplock_break_send(odb, &file->entries[i],
odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
&file->entries[i],
oplock_return);
return NT_STATUS_OPLOCK_NOT_GRANTED;
}
@ -409,30 +418,35 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
}
/*
register an open file in the open files database. This implements the share_access
rules
register an open file in the open files database.
The share_access rules are implemented by odb_can_open()
and it's needed to call odb_can_open() before
odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
Note that the path is only used by the delete on close logic, not
for comparing with other filenames
*/
static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
void *file_handle, const char *path,
uint32_t stream_id, uint32_t share_access,
uint32_t access_mask, bool delete_on_close,
uint32_t open_disposition, bool break_to_none,
bool allow_level_II_oplock,
uint32_t oplock_level, uint32_t *oplock_granted)
{
struct odb_context *odb = lck->odb;
struct opendb_entry e;
struct opendb_file file;
NTSTATUS status;
bool attrs_only = false;
if (!lck->can_open.e) {
return NT_STATUS_INTERNAL_ERROR;
}
if (odb->oplocks == false) {
oplock_level = OPLOCK_NONE;
}
if (!oplock_granted) {
oplock_level = OPLOCK_NONE;
}
status = odb_pull_record(lck, &file);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
/* initialise a blank structure */
@ -442,67 +456,55 @@ static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
NT_STATUS_NOT_OK_RETURN(status);
}
/* see if it conflicts */
status = odb_tdb_open_can_internal(odb, &file, stream_id,
share_access, access_mask,
delete_on_close, open_disposition,
break_to_none, &attrs_only);
NT_STATUS_NOT_OK_RETURN(status);
/* see if it conflicts */
e.server = odb->ntvfs_ctx->server_id;
e.file_handle = file_handle;
e.stream_id = stream_id;
e.share_access = share_access;
e.access_mask = access_mask;
e.delete_on_close = delete_on_close;
e.allow_level_II_oplock = allow_level_II_oplock;
e.oplock_level = OPLOCK_NONE;
/*
possibly grant an exclusive, batch or level2 oplock
*/
if (lck->can_open.attrs_only) {
oplock_level = OPLOCK_NONE;
} else if (oplock_level == OPLOCK_EXCLUSIVE) {
if (file.num_entries == 0) {
oplock_level = OPLOCK_EXCLUSIVE;
} else if (allow_level_II_oplock) {
oplock_level = OPLOCK_LEVEL_II;
} else {
oplock_level = OPLOCK_NONE;
}
} else if (oplock_level == OPLOCK_BATCH) {
if (file.num_entries == 0) {
oplock_level = OPLOCK_BATCH;
} else if (allow_level_II_oplock) {
oplock_level = OPLOCK_LEVEL_II;
} else {
oplock_level = OPLOCK_NONE;
}
} else if (oplock_level == OPLOCK_LEVEL_II) {
oplock_level = OPLOCK_LEVEL_II;
} else {
oplock_level = OPLOCK_NONE;
}
if (oplock_granted) {
if (attrs_only) {
e.oplock_level = OPLOCK_NONE;
*oplock_granted = NO_OPLOCK_RETURN;
} else if (oplock_level == OPLOCK_EXCLUSIVE) {
if (file.num_entries == 0) {
e.oplock_level = OPLOCK_EXCLUSIVE;
*oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
} else if (allow_level_II_oplock) {
e.oplock_level = OPLOCK_LEVEL_II;
*oplock_granted = LEVEL_II_OPLOCK_RETURN;
} else {
e.oplock_level = OPLOCK_NONE;
*oplock_granted = NO_OPLOCK_RETURN;
}
if (oplock_level == OPLOCK_EXCLUSIVE) {
*oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
} else if (oplock_level == OPLOCK_BATCH) {
if (file.num_entries == 0) {
e.oplock_level = OPLOCK_BATCH;
*oplock_granted = BATCH_OPLOCK_RETURN;
} else if (allow_level_II_oplock) {
e.oplock_level = OPLOCK_LEVEL_II;
*oplock_granted = LEVEL_II_OPLOCK_RETURN;
} else {
e.oplock_level = OPLOCK_NONE;
*oplock_granted = NO_OPLOCK_RETURN;
}
*oplock_granted = BATCH_OPLOCK_RETURN;
} else if (oplock_level == OPLOCK_LEVEL_II) {
e.oplock_level = OPLOCK_LEVEL_II;
*oplock_granted = LEVEL_II_OPLOCK_RETURN;
} else {
e.oplock_level = OPLOCK_NONE;
*oplock_granted = NO_OPLOCK_RETURN;
}
}
lck->can_open.e->file_handle = file_handle;
lck->can_open.e->allow_level_II_oplock = allow_level_II_oplock;
lck->can_open.e->oplock_level = oplock_level;
/* it doesn't conflict, so add it to the end */
file.entries = talloc_realloc(lck, file.entries, struct opendb_entry,
file.num_entries+1);
NT_STATUS_HAVE_NO_MEMORY(file.entries);
file.entries[file.num_entries] = e;
file.entries[file.num_entries] = *lck->can_open.e;
file.num_entries++;
return odb_push_record(lck, &file);
@ -655,7 +657,8 @@ static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
* and we just send a break to none to all of them
* without waiting for a release
*/
odb_oplock_break_send(odb, &file.entries[i],
odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
&file.entries[i],
OPLOCK_BREAK_TO_NONE);
file.entries[i].oplock_level = OPLOCK_NONE;
modified = true;
@ -804,20 +807,32 @@ static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
struct odb_context *odb = lck->odb;
NTSTATUS status;
struct opendb_file file;
bool attrs_only = false;
status = odb_pull_record(lck, &file);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
return NT_STATUS_OK;
goto ok;
}
NT_STATUS_NOT_OK_RETURN(status);
status = odb_tdb_open_can_internal(odb, &file, stream_id,
share_access, access_mask,
delete_on_close, open_disposition,
break_to_none, &attrs_only);
break_to_none, &lck->can_open.attrs_only);
NT_STATUS_NOT_OK_RETURN(status);
ok:
lck->can_open.e = talloc(lck, struct opendb_entry);
NT_STATUS_HAVE_NO_MEMORY(lck->can_open.e);
lck->can_open.e->server = odb->ntvfs_ctx->server_id;
lck->can_open.e->file_handle = NULL;
lck->can_open.e->stream_id = stream_id;
lck->can_open.e->share_access = share_access;
lck->can_open.e->access_mask = access_mask;
lck->can_open.e->delete_on_close = delete_on_close;
lck->can_open.e->allow_level_II_oplock = false;
lck->can_open.e->oplock_level = OPLOCK_NONE;
return NT_STATUS_OK;
}

67
source4/ntvfs/posix/pvfs_open.c
View File

@ -290,10 +290,17 @@ static NTSTATUS pvfs_open_directory(struct pvfs_state *pvfs,
}
/* see if we are allowed to open at the same time as existing opens */
status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition,
false, false, OPLOCK_NONE, NULL);
status = odb_can_open(lck, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition, false);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(lck);
return status;
}
/* now really mark the file as open */
status = odb_open_file(lck, f->handle, name->full_name,
false, OPLOCK_NONE, NULL);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(lck);
@ -344,10 +351,16 @@ static NTSTATUS pvfs_open_directory(struct pvfs_state *pvfs,
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition,
false, false, OPLOCK_NONE, NULL);
status = odb_can_open(lck, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition, false);
if (!NT_STATUS_IS_OK(status)) {
goto cleanup_delete;
}
status = odb_open_file(lck, f->handle, name->full_name,
false, OPLOCK_NONE, NULL);
if (!NT_STATUS_IS_OK(status)) {
goto cleanup_delete;
@ -663,10 +676,20 @@ static NTSTATUS pvfs_create_file(struct pvfs_state *pvfs,
allow_level_II_oplock = true;
}
status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition,
false, allow_level_II_oplock,
status = odb_can_open(lck, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition, false);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(lck);
/* bad news, we must have hit a race - we don't delete the file
here as the most likely scenario is that someone else created
the file at the same time */
close(fd);
return status;
}
status = odb_open_file(lck, f->handle, name->full_name,
allow_level_II_oplock,
oplock_level, &oplock_granted);
talloc_free(lck);
if (!NT_STATUS_IS_OK(status)) {
@ -801,7 +824,7 @@ static void pvfs_odb_retry_callback(void *_r, enum pvfs_wait_notice reason)
/*
setup for a retry of a request that was rejected
by odb_open_file() or odb_can_open()
by odb_can_open()
*/
NTSTATUS pvfs_odb_retry_setup(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
@ -1253,11 +1276,9 @@ NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs,
}
/* see if we are allowed to open at the same time as existing opens */
status = odb_open_file(lck, f->handle, name->full_name, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition,
false, allow_level_II_oplock,
oplock_level, &oplock_granted);
status = odb_can_open(lck, name->stream_id,
share_access, access_mask, del_on_close,
io->generic.in.open_disposition, false);
/*
* on a sharing violation we need to retry when the file is closed by
@ -1276,6 +1297,16 @@ NTSTATUS pvfs_open(struct ntvfs_module_context *ntvfs,
return status;
}
/* now really mark the file as open */
status = odb_open_file(lck, f->handle, name->full_name,
allow_level_II_oplock,
oplock_level, &oplock_granted);
if (!NT_STATUS_IS_OK(status)) {
talloc_free(lck);
return status;
}
if (pvfs->flags & PVFS_FLAG_FAKE_OPLOCKS) {
oplock_granted = OPLOCK_BATCH;
} else if (oplock_granted != OPLOCK_NONE) {