#include "includes.h"
-extern char *OutBuffer;
-
/****************************************************************************
This is the structure to queue to implement blocking locks.
notify. It consists of the requesting SMB and the expiry time.
*****************************************************************************/
-typedef struct {
- ubi_slNode msg_next;
+typedef struct _blocking_lock_record {
+ struct _blocking_lock_record *next;
+ struct _blocking_lock_record *prev;
int com_type;
files_struct *fsp;
time_t expire_time;
int length;
} blocking_lock_record;
-static ubi_slList blocking_lock_queue = { NULL, (ubi_slNodePtr)&blocking_lock_queue, 0};
+static blocking_lock_record *blocking_lock_queue;
/****************************************************************************
Destructor for the above structure.
static void free_blocking_lock_record(blocking_lock_record *blr)
{
+ DLIST_REMOVE(blocking_lock_queue, blr);
SAFE_FREE(blr->inbuf);
SAFE_FREE(blr);
}
return (chain_size != 0);
}
-static void received_unlock_msg(int msg_type, pid_t src, void *buf, size_t len);
+static void received_unlock_msg(int msg_type, struct process_id src,
+ void *buf, size_t len);
/****************************************************************************
Function to push a blocking lock request onto the lock queue.
int lock_num, uint16 lock_pid, SMB_BIG_UINT offset, SMB_BIG_UINT count)
{
static BOOL set_lock_msg;
- blocking_lock_record *blr;
+ blocking_lock_record *blr, *tmp;
+ BOOL my_lock_ctx = False;
NTSTATUS status;
if(in_chained_smb() ) {
* the expiration time here.
*/
- if((blr = (blocking_lock_record *)malloc(sizeof(blocking_lock_record))) == NULL) {
+ if((blr = SMB_MALLOC_P(blocking_lock_record)) == NULL) {
DEBUG(0,("push_blocking_lock_request: Malloc fail !\n" ));
return False;
}
- if((blr->inbuf = (char *)malloc(length)) == NULL) {
+ if((blr->inbuf = (char *)SMB_MALLOC(length)) == NULL) {
DEBUG(0,("push_blocking_lock_request: Malloc fail (2)!\n" ));
SAFE_FREE(blr);
return False;
/* Add a pending lock record for this. */
status = brl_lock(blr->fsp->dev, blr->fsp->inode, blr->fsp->fnum,
- lock_pid, sys_getpid(), blr->fsp->conn->cnum,
- offset, count, PENDING_LOCK);
+ lock_pid, procid_self(), blr->fsp->conn->cnum,
+ offset, count, PENDING_LOCK, &my_lock_ctx);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("push_blocking_lock_request: failed to add PENDING_LOCK record.\n"));
return False;
}
- ubi_slAddTail(&blocking_lock_queue, blr);
+ DLIST_ADD_END(blocking_lock_queue, blr, tmp);
/* Ensure we'll receive messages when this is unlocked. */
if (!set_lock_msg) {
blr->fsp->fnum, blr->fsp->fsp_name ));
/* Push the MID of this packet on the signing queue. */
- srv_defer_sign_response(SVAL(inbuf,smb_mid), True);
+ srv_defer_sign_response(SVAL(inbuf,smb_mid));
return True;
}
static void reply_lockingX_success(blocking_lock_record *blr)
{
- char *outbuf = OutBuffer;
+ char *outbuf = get_OutBuffer();
int bufsize = BUFFER_SIZE;
char *inbuf = blr->inbuf;
int outsize = 0;
static void generic_blocking_lock_error(blocking_lock_record *blr, NTSTATUS status)
{
- char *outbuf = OutBuffer;
+ char *outbuf = get_OutBuffer();
char *inbuf = blr->inbuf;
construct_reply_common(inbuf, outbuf);
static BOOL process_lockread(blocking_lock_record *blr)
{
- char *outbuf = OutBuffer;
+ char *outbuf = get_OutBuffer();
char *inbuf = blr->inbuf;
ssize_t nread = -1;
char *data, *p;
NTSTATUS status;
connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
files_struct *fsp = blr->fsp;
+ BOOL my_lock_ctx = False;
numtoread = SVAL(inbuf,smb_vwv1);
startpos = (SMB_BIG_UINT)IVAL(inbuf,smb_vwv2);
numtoread = MIN(BUFFER_SIZE-outsize,numtoread);
data = smb_buf(outbuf) + 3;
- status = do_lock_spin( fsp, conn, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)numtoread,
- startpos, READ_LOCK);
+ status = do_lock_spin( fsp, conn, SVAL(inbuf,smb_pid), (SMB_BIG_UINT)numtoread, startpos, READ_LOCK, &my_lock_ctx);
if (NT_STATUS_V(status)) {
if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
!NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
SSVAL(p,0,nread); p += 2;
set_message_end(outbuf, p+nread);
- DEBUG(3, ( "process_lockread file = %s, fnum=%d num=%d nread=%d\n",
- fsp->fsp_name, fsp->fnum, (int)numtoread, (int)nread ) );
+ DEBUG(3, ( "process_lockread file = %s, fnum=%d num=%lu nread=%ld\n",
+ fsp->fsp_name, fsp->fnum, (unsigned long)numtoread, (long)nread ) );
send_blocking_reply(outbuf,outsize);
return True;
static BOOL process_lock(blocking_lock_record *blr)
{
- char *outbuf = OutBuffer;
+ char *outbuf = get_OutBuffer();
char *inbuf = blr->inbuf;
int outsize;
SMB_BIG_UINT count = (SMB_BIG_UINT)0, offset = (SMB_BIG_UINT)0;
NTSTATUS status;
connection_struct *conn = conn_find(SVAL(inbuf,smb_tid));
files_struct *fsp = blr->fsp;
+ BOOL my_lock_ctx = False;
count = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv1);
offset = IVAL_TO_SMB_OFF_T(inbuf,smb_vwv3);
errno = 0;
- status = do_lock_spin(fsp, conn, SVAL(inbuf,smb_pid), count,
- offset, WRITE_LOCK);
+ status = do_lock_spin(fsp, conn, SVAL(inbuf,smb_pid), count, offset, WRITE_LOCK, &my_lock_ctx);
if (NT_STATUS_IS_ERR(status)) {
if (!NT_STATUS_EQUAL(status,NT_STATUS_LOCK_NOT_GRANTED) &&
!NT_STATUS_EQUAL(status,NT_STATUS_FILE_LOCK_CONFLICT)) {
uint16 lock_pid;
BOOL large_file_format = (locktype & LOCKING_ANDX_LARGE_FILES);
char *data;
+ BOOL my_lock_ctx = False;
NTSTATUS status = NT_STATUS_OK;
data = smb_buf(inbuf) + ((large_file_format ? 20 : 10)*num_ulocks);
*/
errno = 0;
status = do_lock_spin(fsp,conn,lock_pid,count,offset,
- ((locktype & 1) ? READ_LOCK : WRITE_LOCK));
+ ((locktype & 1) ? READ_LOCK : WRITE_LOCK), &my_lock_ctx);
if (NT_STATUS_IS_ERR(status)) break;
}
void remove_pending_lock_requests_by_fid(files_struct *fsp)
{
- blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
- blocking_lock_record *prev = NULL;
+ blocking_lock_record *blr, *next = NULL;
- while(blr != NULL) {
+ for(blr = blocking_lock_queue; blr; blr = next) {
+ next = blr->next;
if(blr->fsp->fnum == fsp->fnum) {
DEBUG(10,("remove_pending_lock_requests_by_fid - removing request type %d for \
file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
brl_unlock(blr->fsp->dev, blr->fsp->inode, blr->fsp->fnum,
- blr->lock_pid, sys_getpid(), blr->fsp->conn->cnum,
+ blr->lock_pid, procid_self(), blr->fsp->conn->cnum,
blr->offset, blr->count, True, NULL, NULL);
- free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
- blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
- continue;
+ free_blocking_lock_record(blr);
}
-
- prev = blr;
- blr = (blocking_lock_record *)ubi_slNext(blr);
}
}
void remove_pending_lock_requests_by_mid(int mid)
{
- blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
- blocking_lock_record *prev = NULL;
+ blocking_lock_record *blr, *next = NULL;
- while(blr != NULL) {
+ for(blr = blocking_lock_queue; blr; blr = next) {
+ next = blr->next;
if(SVAL(blr->inbuf,smb_mid) == mid) {
files_struct *fsp = blr->fsp;
DEBUG(10,("remove_pending_lock_requests_by_mid - removing request type %d for \
file %s fnum = %d\n", blr->com_type, fsp->fsp_name, fsp->fnum ));
- blocking_lock_reply_error(blr,NT_STATUS_CANCELLED);
+ blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
brl_unlock(blr->fsp->dev, blr->fsp->inode, blr->fsp->fnum,
- blr->lock_pid, sys_getpid(), blr->fsp->conn->cnum,
+ blr->lock_pid, procid_self(), blr->fsp->conn->cnum,
blr->offset, blr->count, True, NULL, NULL);
- free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
- blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
- continue;
+ free_blocking_lock_record(blr);
}
-
- prev = blr;
- blr = (blocking_lock_record *)ubi_slNext(blr);
}
}
Set a flag as an unlock request affects one of our pending locks.
*****************************************************************************/
-static void received_unlock_msg(int msg_type, pid_t src, void *buf, size_t len)
+static void received_unlock_msg(int msg_type, struct process_id src,
+ void *buf, size_t len)
{
DEBUG(10,("received_unlock_msg\n"));
process_blocking_lock_queue(time(NULL));
{
unsigned timeout = default_timeout;
time_t t;
- blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst(&blocking_lock_queue);
+ blocking_lock_record *blr = blocking_lock_queue;
/* note that we avoid the time() syscall if there are no blocking locks */
if (!blr)
t = time(NULL);
- while (blr) {
+ for (; blr; blr = blr->next) {
if ((blr->expire_time != (time_t)-1) &&
(timeout > (blr->expire_time - t))) {
timeout = blr->expire_time - t;
}
- blr = (blocking_lock_record *)ubi_slNext(blr);
}
if (timeout < 1)
void process_blocking_lock_queue(time_t t)
{
- blocking_lock_record *blr = (blocking_lock_record *)ubi_slFirst( &blocking_lock_queue );
- blocking_lock_record *prev = NULL;
-
- if(blr == NULL)
- return;
+ blocking_lock_record *blr, *next = NULL;
/*
* Go through the queue and see if we can get any of the locks.
*/
- while(blr != NULL) {
+ for (blr = blocking_lock_queue; blr; blr = next) {
connection_struct *conn = NULL;
uint16 vuid;
files_struct *fsp = NULL;
+ next = blr->next;
+
/*
* Ensure we don't have any old chain_fsp values
* sitting around....
fsp->fnum, fsp->fsp_name ));
brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
- blr->lock_pid, sys_getpid(), conn->cnum,
+ blr->lock_pid, procid_self(), conn->cnum,
blr->offset, blr->count, True, NULL, NULL);
blocking_lock_reply_error(blr,NT_STATUS_FILE_LOCK_CONFLICT);
- free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
- blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+ free_blocking_lock_record(blr);
continue;
}
blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
- blr->lock_pid, sys_getpid(), conn->cnum,
+ blr->lock_pid, procid_self(), conn->cnum,
blr->offset, blr->count, True, NULL, NULL);
- free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
- blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+ free_blocking_lock_record(blr);
continue;
}
- if(!set_current_service(conn,True)) {
+ if(!set_current_service(conn,SVAL(blr->inbuf,smb_flg),True)) {
DEBUG(0,("process_blocking_lock_queue: Unable to become service Error was %s.\n", strerror(errno) ));
/*
* Remove the entry and return an error to the client.
blocking_lock_reply_error(blr,NT_STATUS_ACCESS_DENIED);
brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
- blr->lock_pid, sys_getpid(), conn->cnum,
+ blr->lock_pid, procid_self(), conn->cnum,
blr->offset, blr->count, True, NULL, NULL);
- free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
- blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
+ free_blocking_lock_record(blr);
change_to_root_user();
continue;
}
if(blocking_lock_record_process(blr)) {
brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
- blr->lock_pid, sys_getpid(), conn->cnum,
+ blr->lock_pid, procid_self(), conn->cnum,
blr->offset, blr->count, True, NULL, NULL);
- free_blocking_lock_record((blocking_lock_record *)ubi_slRemNext( &blocking_lock_queue, prev));
- blr = (blocking_lock_record *)(prev ? ubi_slNext(prev) : ubi_slFirst(&blocking_lock_queue));
- change_to_root_user();
- continue;
+ free_blocking_lock_record(blr);
}
-
change_to_root_user();
-
- /*
- * Move to the next in the list.
- */
- prev = blr;
- blr = (blocking_lock_record *)ubi_slNext(blr);
}
}
git.samba.org / vlendec / samba-autobuild / .git / blobdiff