we're calling this in a shutting down state.
****************************************************************************/
-void process_kernel_oplocks(fd_set *pfds)
+void process_kernel_oplocks(struct messaging_context *msg_ctx, fd_set *pfds)
{
/*
* We need to check for kernel oplocks before going into the select
}
/* Put the kernel break info into the message. */
- SDEV_T_VAL(msg,0,fsp->dev);
- SINO_T_VAL(msg,8,fsp->inode);
- SIVAL(msg,16,fsp->fh->file_id);
+ push_file_id_16(msg, &fsp->file_id);
+ SIVAL(msg,16,fsp->fh->gen_id);
/* Don't need to be root here as we're only ever
sending to ourselves. */
- message_send_pid(pid_to_procid(sys_getpid()),
- MSG_SMB_KERNEL_BREAK,
- &msg, MSG_SMB_KERNEL_BREAK_SIZE, True);
+ messaging_send_buf(msg_ctx, procid_self(),
+ MSG_SMB_KERNEL_BREAK,
+ (uint8 *)&msg, MSG_SMB_KERNEL_BREAK_SIZE);
}
}
exclusive_oplocks_open++;
}
- DEBUG(5,("set_file_oplock: granted oplock on file %s, 0x%x/%.0f/%lu, "
+ DEBUG(5,("set_file_oplock: granted oplock on file %s, %s/%lu, "
"tv_sec = %x, tv_usec = %x\n",
- fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode,
- fsp->fh->file_id, (int)fsp->open_time.tv_sec,
+ fsp->fsp_name, file_id_static_string(&fsp->file_id),
+ fsp->fh->gen_id, (int)fsp->open_time.tv_sec,
(int)fsp->open_time.tv_usec ));
return True;
BOOL remove_oplock(files_struct *fsp)
{
- SMB_DEV_T dev = fsp->dev;
- SMB_INO_T inode = fsp->inode;
BOOL ret;
struct share_mode_lock *lck;
/* Remove the oplock flag from the sharemode. */
- lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
+ lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
if (lck == NULL) {
DEBUG(0,("remove_oplock: failed to lock share entry for "
"file %s\n", fsp->fsp_name ));
ret = remove_share_oplock(lck, fsp);
if (!ret) {
DEBUG(0,("remove_oplock: failed to remove share oplock for "
- "file %s fnum %d, 0x%x/%.0f\n",
- fsp->fsp_name, fsp->fnum, (unsigned int)dev,
- (double)inode));
+ "file %s fnum %d, %s\n",
+ fsp->fsp_name, fsp->fnum, file_id_static_string(&fsp->file_id)));
}
release_file_oplock(fsp);
TALLOC_FREE(lck);
*/
BOOL downgrade_oplock(files_struct *fsp)
{
- SMB_DEV_T dev = fsp->dev;
- SMB_INO_T inode = fsp->inode;
BOOL ret;
struct share_mode_lock *lck;
- lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
+ lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
if (lck == NULL) {
DEBUG(0,("downgrade_oplock: failed to lock share entry for "
"file %s\n", fsp->fsp_name ));
ret = downgrade_share_oplock(lck, fsp);
if (!ret) {
DEBUG(0,("downgrade_oplock: failed to downgrade share oplock "
- "for file %s fnum %d, dev = %x, inode = %.0f\n",
- fsp->fsp_name, fsp->fnum, (unsigned int)dev,
- (double)inode));
+ "for file %s fnum %d, file_id %s\n",
+ fsp->fsp_name, fsp->fnum, file_id_static_string(&fsp->file_id)));
}
downgrade_file_oplock(fsp);
}
memset(result,'\0',smb_size);
- set_message(result,8,0,True);
+ set_message(NULL,result,8,0,True);
SCVAL(result,smb_com,SMBlockingX);
SSVAL(result,smb_tid,fsp->conn->cnum);
SSVAL(result,smb_pid,0xFFFF);
Ensure that we have a valid oplock.
****************************************************************************/
-static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id)
+static files_struct *initial_break_processing(struct file_id id, unsigned long file_id)
{
files_struct *fsp = NULL;
if( DEBUGLVL( 3 ) ) {
- dbgtext( "initial_break_processing: called for 0x%x/%.0f/%u\n",
- (unsigned int)dev, (double)inode, (int)file_id);
+ dbgtext( "initial_break_processing: called for %s/%u\n",
+ file_id_static_string(&id), (int)file_id);
dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
exclusive_oplocks_open, level_II_oplocks_open );
}
* we have an oplock on it.
*/
- fsp = file_find_dif(dev, inode, file_id);
+ fsp = file_find_dif(id, file_id);
if(fsp == NULL) {
/* The file could have been closed in the meantime - return success. */
if( DEBUGLVL( 3 ) ) {
dbgtext( "initial_break_processing: cannot find open file with " );
- dbgtext( "dev = 0x%x, inode = %.0f file_id = %lu", (unsigned int)dev,
- (double)inode, file_id);
+ dbgtext( "file_id %s gen_id = %lu", file_id_static_string(&id), file_id);
dbgtext( "allowing break to succeed.\n" );
}
return NULL;
if(fsp->oplock_type == NO_OPLOCK) {
if( DEBUGLVL( 3 ) ) {
dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
- dbgtext( "(dev = %x, inode = %.0f, file_id = %lu) has no oplock.\n",
- (unsigned int)dev, (double)inode, fsp->fh->file_id );
+ dbgtext( "(file_id = %s gen_id = %lu) has no oplock.\n",
+ file_id_static_string(&id), fsp->fh->gen_id );
dbgtext( "Allowing break to succeed regardless.\n" );
}
return NULL;
return fsp;
}
-static void oplock_timeout_handler(struct timed_event *te,
+static void oplock_timeout_handler(struct event_context *ctx,
+ struct timed_event *te,
const struct timeval *now,
void *private_data)
{
files_struct *fsp = (files_struct *)private_data;
+ /* Ensure we always remove this event. */
+ if (fsp->oplock_timeout != NULL) {
+ /* Remove the timed event handler. */
+ TALLOC_FREE(fsp->oplock_timeout);
+ fsp->oplock_timeout = NULL;
+ }
DEBUG(0, ("Oplock break failed for file %s -- replying anyway\n", fsp->fsp_name));
global_client_failed_oplock_break = True;
remove_oplock(fsp);
}
fsp->oplock_timeout =
- add_timed_event(NULL,
+ event_add_timed(smbd_event_context(), NULL,
timeval_current_ofs(OPLOCK_BREAK_TIMEOUT, 0),
"oplock_timeout_handler",
oplock_timeout_handler, fsp);
the client for LEVEL2.
*******************************************************************/
-static void process_oplock_async_level2_break_message(int msg_type, struct process_id src,
- void *buf, size_t len)
+static void process_oplock_async_level2_break_message(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
{
struct share_mode_entry msg;
files_struct *fsp;
char *break_msg;
BOOL sign_state;
- if (buf == NULL) {
+ if (data->data == NULL) {
DEBUG(0, ("Got NULL buffer\n"));
return;
}
- if (len != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
- DEBUG(0, ("Got invalid msg len %d\n", (int)len));
+ if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
+ DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
return;
}
/* De-linearize incoming message. */
- message_to_share_mode_entry(&msg, (char *)buf);
+ message_to_share_mode_entry(&msg, (char *)data->data);
- DEBUG(10, ("Got oplock async level 2 break message from pid %d: 0x%x/%.0f/%lu\n",
- (int)procid_to_pid(&src), (unsigned int)msg.dev,
- (double)msg.inode, msg.share_file_id));
+ DEBUG(10, ("Got oplock async level 2 break message from pid %d: %s/%lu\n",
+ (int)procid_to_pid(&src), file_id_static_string(&msg.id), msg.share_file_id));
- fsp = initial_break_processing(msg.dev, msg.inode,
- msg.share_file_id);
+ fsp = initial_break_processing(msg.id, msg.share_file_id);
if (fsp == NULL) {
/* We hit a race here. Break messages are sent, and before we
show_msg(break_msg);
if (!send_smb(smbd_server_fd(), break_msg)) {
- exit_server("oplock_break: send_smb failed.");
+ exit_server_cleanly("oplock_break: send_smb failed.");
}
/* Restore the sign state to what it was. */
This handles the generic oplock break message from another smbd.
*******************************************************************/
-static void process_oplock_break_message(int msg_type, struct process_id src,
- void *buf, size_t len)
+static void process_oplock_break_message(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
{
struct share_mode_entry msg;
files_struct *fsp;
BOOL break_to_level2 = False;
BOOL sign_state;
- if (buf == NULL) {
+ if (data->data == NULL) {
DEBUG(0, ("Got NULL buffer\n"));
return;
}
- if (len != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
- DEBUG(0, ("Got invalid msg len %d\n", (int)len));
+ if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
+ DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
return;
}
/* De-linearize incoming message. */
- message_to_share_mode_entry(&msg, (char *)buf);
+ message_to_share_mode_entry(&msg, (char *)data->data);
- DEBUG(10, ("Got oplock break message from pid %d: 0x%x/%.0f/%lu\n",
- (int)procid_to_pid(&src), (unsigned int)msg.dev,
- (double)msg.inode, msg.share_file_id));
+ DEBUG(10, ("Got oplock break message from pid %d: %s/%lu\n",
+ (int)procid_to_pid(&src), file_id_static_string(&msg.id), msg.share_file_id));
- fsp = initial_break_processing(msg.dev, msg.inode,
- msg.share_file_id);
+ fsp = initial_break_processing(msg.id, msg.share_file_id);
if (fsp == NULL) {
/* a We hit race here. Break messages are sent, and before we
DEBUG(3, ("Did not find fsp\n"));
/* We just send the same message back. */
- message_send_pid(src, MSG_SMB_BREAK_RESPONSE,
- buf, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
+ messaging_send_buf(msg_ctx, src, MSG_SMB_BREAK_RESPONSE,
+ (uint8 *)data->data,
+ MSG_SMB_SHARE_MODE_ENTRY_SIZE);
return;
}
if (EXCLUSIVE_OPLOCK_TYPE(msg.op_type) &&
!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
- DEBUG(3, ("Already downgraded oplock on 0x%x/%.0f: %s\n",
- (unsigned int)fsp->dev, (double)fsp->inode,
+ DEBUG(3, ("Already downgraded oplock on %s: %s\n",
+ file_id_static_string(&fsp->file_id),
fsp->fsp_name));
/* We just send the same message back. */
- message_send_pid(src, MSG_SMB_BREAK_RESPONSE,
- buf, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
+ messaging_send_buf(msg_ctx, src, MSG_SMB_BREAK_RESPONSE,
+ (uint8 *)data->data,
+ MSG_SMB_SHARE_MODE_ENTRY_SIZE);
return;
}
show_msg(break_msg);
if (!send_smb(smbd_server_fd(), break_msg)) {
- exit_server("oplock_break: send_smb failed.");
+ exit_server_cleanly("oplock_break: send_smb failed.");
}
/* Restore the sign state to what it was. */
This handles the kernel oplock break message.
*******************************************************************/
-static void process_kernel_oplock_break(int msg_type, struct process_id src,
- void *buf, size_t len)
+static void process_kernel_oplock_break(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
{
- SMB_DEV_T dev;
- SMB_INO_T inode;
+ struct file_id id;
unsigned long file_id;
files_struct *fsp;
char *break_msg;
BOOL sign_state;
- if (buf == NULL) {
+ if (data->data == NULL) {
DEBUG(0, ("Got NULL buffer\n"));
return;
}
- if (len != MSG_SMB_KERNEL_BREAK_SIZE) {
- DEBUG(0, ("Got invalid msg len %d\n", (int)len));
+ if (data->length != MSG_SMB_KERNEL_BREAK_SIZE) {
+ DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
return;
}
/* Pull the data from the message. */
- dev = DEV_T_VAL(buf, 0);
- inode = INO_T_VAL(buf, 8);
- file_id = (unsigned long)IVAL(buf, 16);
+ pull_file_id_16((char *)data->data, &id);
+ file_id = (unsigned long)IVAL(data->data, 16);
- DEBUG(10, ("Got kernel oplock break message from pid %d: 0x%x/%.0f/%u\n",
- (int)procid_to_pid(&src), (unsigned int)dev, (double)inode,
+ DEBUG(10, ("Got kernel oplock break message from pid %d: %s/%u\n",
+ (int)procid_to_pid(&src), file_id_static_string(&id),
(unsigned int)file_id));
- fsp = initial_break_processing(dev, inode, file_id);
+ fsp = initial_break_processing(id, file_id);
if (fsp == NULL) {
DEBUG(3, ("Got a kernel oplock break message for a file "
show_msg(break_msg);
if (!send_smb(smbd_server_fd(), break_msg)) {
- exit_server("oplock_break: send_smb failed.");
+ exit_server_cleanly("oplock_break: send_smb failed.");
}
/* Restore the sign state to what it was. */
share_mode_entry_to_message(msg, e);
- message_send_pid(e->pid, MSG_SMB_BREAK_RESPONSE,
- msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
+ messaging_send_buf(smbd_messaging_context(), e->pid,
+ MSG_SMB_BREAK_RESPONSE,
+ (uint8 *)msg,
+ MSG_SMB_SHARE_MODE_ENTRY_SIZE);
}
SAFE_FREE(fsp->pending_break_messages);
return;
}
-static void process_oplock_break_response(int msg_type, struct process_id src,
- void *buf, size_t len)
+static void process_oplock_break_response(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
{
struct share_mode_entry msg;
- if (buf == NULL) {
+ if (data->data == NULL) {
DEBUG(0, ("Got NULL buffer\n"));
return;
}
- if (len != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
- DEBUG(0, ("Got invalid msg len %u\n", (unsigned int)len));
+ if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
+ DEBUG(0, ("Got invalid msg len %u\n",
+ (unsigned int)data->length));
return;
}
/* De-linearize incoming message. */
- message_to_share_mode_entry(&msg, (char *)buf);
+ message_to_share_mode_entry(&msg, (char *)data->data);
- DEBUG(10, ("Got oplock break response from pid %d: 0x%x/%.0f/%lu mid %u\n",
- (int)procid_to_pid(&src), (unsigned int)msg.dev,
- (double)msg.inode, msg.share_file_id,
+ DEBUG(10, ("Got oplock break response from pid %d: %s/%lu mid %u\n",
+ (int)procid_to_pid(&src), file_id_static_string(&msg.id), msg.share_file_id,
(unsigned int)msg.op_mid));
/* Here's the hack from open.c, store the mid in the 'port' field */
schedule_deferred_open_smb_message(msg.op_mid);
}
-static void process_open_retry_message(int msg_type, struct process_id src,
- void *buf, size_t len)
+static void process_open_retry_message(struct messaging_context *msg_ctx,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id src,
+ DATA_BLOB *data)
{
struct share_mode_entry msg;
- if (buf == NULL) {
+ if (data->data == NULL) {
DEBUG(0, ("Got NULL buffer\n"));
return;
}
- if (len != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
- DEBUG(0, ("Got invalid msg len %d\n", (int)len));
+ if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
+ DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
return;
}
/* De-linearize incoming message. */
- message_to_share_mode_entry(&msg, (char *)buf);
+ message_to_share_mode_entry(&msg, (char *)data->data);
- DEBUG(10, ("Got open retry msg from pid %d: 0x%x/%.0f/%lu mid %u\n",
- (int)procid_to_pid(&src), (unsigned int)msg.dev,
- (double)msg.inode, msg.share_file_id,
+ DEBUG(10, ("Got open retry msg from pid %d: %s mid %u\n",
+ (int)procid_to_pid(&src), file_id_static_string(&msg.id),
(unsigned int)msg.op_mid));
schedule_deferred_open_smb_message(msg.op_mid);
if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
return;
- lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
+ lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
if (lck == NULL) {
DEBUG(0,("release_level_2_oplocks_on_change: failed to lock "
"share mode entry for file %s.\n", fsp->fsp_name ));
share_mode_entry_to_message(msg, share_entry);
- message_send_pid(share_entry->pid, MSG_SMB_ASYNC_LEVEL2_BREAK,
- msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
+ messaging_send_buf(smbd_messaging_context(), share_entry->pid,
+ MSG_SMB_ASYNC_LEVEL2_BREAK,
+ (uint8 *)msg,
+ MSG_SMB_SHARE_MODE_ENTRY_SIZE);
}
/* We let the message receivers handle removing the oplock state
SIVAL(msg,16,e->private_options);
SIVAL(msg,20,(uint32)e->time.tv_sec);
SIVAL(msg,24,(uint32)e->time.tv_usec);
- SDEV_T_VAL(msg,28,e->dev);
- SINO_T_VAL(msg,36,e->inode);
+ push_file_id_16(msg+28, &e->id);
SIVAL(msg,44,e->share_file_id);
SIVAL(msg,48,e->uid);
+ SSVAL(msg,52,e->flags);
+#ifdef CLUSTER_SUPPORT
+ SIVAL(msg,54,e->pid.vnn);
+#endif
}
/****************************************************************************
e->private_options = IVAL(msg,16);
e->time.tv_sec = (time_t)IVAL(msg,20);
e->time.tv_usec = (int)IVAL(msg,24);
- e->dev = DEV_T_VAL(msg,28);
- e->inode = INO_T_VAL(msg,36);
+ pull_file_id_16(msg+28, &e->id);
e->share_file_id = (unsigned long)IVAL(msg,44);
e->uid = (uint32)IVAL(msg,48);
+ e->flags = (uint16)SVAL(msg,52);
+#ifdef CLUSTER_SUPPORT
+ e->pid.vnn = IVAL(msg,54);
+#endif
}
/****************************************************************************
Setup oplocks for this process.
****************************************************************************/
-BOOL init_oplocks(void)
+BOOL init_oplocks(struct messaging_context *msg_ctx)
{
DEBUG(3,("init_oplocks: initializing messages.\n"));
- message_register(MSG_SMB_BREAK_REQUEST,
- process_oplock_break_message);
- message_register(MSG_SMB_ASYNC_LEVEL2_BREAK,
- process_oplock_async_level2_break_message);
- message_register(MSG_SMB_BREAK_RESPONSE,
- process_oplock_break_response);
- message_register(MSG_SMB_KERNEL_BREAK,
- process_kernel_oplock_break);
- message_register(MSG_SMB_OPEN_RETRY,
- process_open_retry_message);
+ messaging_register(msg_ctx, NULL, MSG_SMB_BREAK_REQUEST,
+ process_oplock_break_message);
+ messaging_register(msg_ctx, NULL, MSG_SMB_ASYNC_LEVEL2_BREAK,
+ process_oplock_async_level2_break_message);
+ messaging_register(msg_ctx, NULL, MSG_SMB_BREAK_RESPONSE,
+ process_oplock_break_response);
+ messaging_register(msg_ctx, NULL, MSG_SMB_KERNEL_BREAK,
+ process_kernel_oplock_break);
+ messaging_register(msg_ctx, NULL, MSG_SMB_OPEN_RETRY,
+ process_open_retry_message);
if (lp_kernel_oplocks()) {
#if HAVE_KERNEL_OPLOCKS_IRIX
git.samba.org / tprouty / samba.git / blobdiff