mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 02:39:48 +00:00
![Al Viro](/assets/img/avatar_default.png)
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
345 lines
7.5 KiB
C
345 lines
7.5 KiB
C
/*
|
|
* smbiod.c
|
|
*
|
|
* Copyright (C) 2000, Charles Loep / Corel Corp.
|
|
* Copyright (C) 2001, Urban Widmark
|
|
*/
|
|
|
|
|
|
#include <linux/sched.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/string.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/init.h>
|
|
#include <linux/file.h>
|
|
#include <linux/dcache.h>
|
|
#include <linux/module.h>
|
|
#include <linux/net.h>
|
|
#include <linux/kthread.h>
|
|
#include <net/ip.h>
|
|
|
|
#include <linux/smb_fs.h>
|
|
#include <linux/smbno.h>
|
|
#include <linux/smb_mount.h>
|
|
|
|
#include <asm/system.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "smb_debug.h"
|
|
#include "request.h"
|
|
#include "proto.h"
|
|
|
|
enum smbiod_state {
|
|
SMBIOD_DEAD,
|
|
SMBIOD_STARTING,
|
|
SMBIOD_RUNNING,
|
|
};
|
|
|
|
static enum smbiod_state smbiod_state = SMBIOD_DEAD;
|
|
static struct task_struct *smbiod_thread;
|
|
static DECLARE_WAIT_QUEUE_HEAD(smbiod_wait);
|
|
static LIST_HEAD(smb_servers);
|
|
static DEFINE_SPINLOCK(servers_lock);
|
|
|
|
#define SMBIOD_DATA_READY (1<<0)
|
|
static unsigned long smbiod_flags;
|
|
|
|
static int smbiod(void *);
|
|
static int smbiod_start(void);
|
|
|
|
/*
|
|
* called when there's work for us to do
|
|
*/
|
|
void smbiod_wake_up(void)
|
|
{
|
|
if (smbiod_state == SMBIOD_DEAD)
|
|
return;
|
|
set_bit(SMBIOD_DATA_READY, &smbiod_flags);
|
|
wake_up_interruptible(&smbiod_wait);
|
|
}
|
|
|
|
/*
|
|
* start smbiod if none is running
|
|
*/
|
|
static int smbiod_start(void)
|
|
{
|
|
struct task_struct *tsk;
|
|
int err = 0;
|
|
|
|
if (smbiod_state != SMBIOD_DEAD)
|
|
return 0;
|
|
smbiod_state = SMBIOD_STARTING;
|
|
__module_get(THIS_MODULE);
|
|
spin_unlock(&servers_lock);
|
|
tsk = kthread_run(smbiod, NULL, "smbiod");
|
|
if (IS_ERR(tsk)) {
|
|
err = PTR_ERR(tsk);
|
|
module_put(THIS_MODULE);
|
|
}
|
|
|
|
spin_lock(&servers_lock);
|
|
if (err < 0) {
|
|
smbiod_state = SMBIOD_DEAD;
|
|
smbiod_thread = NULL;
|
|
} else {
|
|
smbiod_state = SMBIOD_RUNNING;
|
|
smbiod_thread = tsk;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* register a server & start smbiod if necessary
|
|
*/
|
|
int smbiod_register_server(struct smb_sb_info *server)
|
|
{
|
|
int ret;
|
|
spin_lock(&servers_lock);
|
|
list_add(&server->entry, &smb_servers);
|
|
VERBOSE("%p\n", server);
|
|
ret = smbiod_start();
|
|
spin_unlock(&servers_lock);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Unregister a server
|
|
* Must be called with the server lock held.
|
|
*/
|
|
void smbiod_unregister_server(struct smb_sb_info *server)
|
|
{
|
|
spin_lock(&servers_lock);
|
|
list_del_init(&server->entry);
|
|
VERBOSE("%p\n", server);
|
|
spin_unlock(&servers_lock);
|
|
|
|
smbiod_wake_up();
|
|
smbiod_flush(server);
|
|
}
|
|
|
|
void smbiod_flush(struct smb_sb_info *server)
|
|
{
|
|
struct list_head *tmp, *n;
|
|
struct smb_request *req;
|
|
|
|
list_for_each_safe(tmp, n, &server->xmitq) {
|
|
req = list_entry(tmp, struct smb_request, rq_queue);
|
|
req->rq_errno = -EIO;
|
|
list_del_init(&req->rq_queue);
|
|
smb_rput(req);
|
|
wake_up_interruptible(&req->rq_wait);
|
|
}
|
|
list_for_each_safe(tmp, n, &server->recvq) {
|
|
req = list_entry(tmp, struct smb_request, rq_queue);
|
|
req->rq_errno = -EIO;
|
|
list_del_init(&req->rq_queue);
|
|
smb_rput(req);
|
|
wake_up_interruptible(&req->rq_wait);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Wake up smbmount and make it reconnect to the server.
|
|
* This must be called with the server locked.
|
|
*
|
|
* FIXME: add smbconnect version to this
|
|
*/
|
|
int smbiod_retry(struct smb_sb_info *server)
|
|
{
|
|
struct list_head *head;
|
|
struct smb_request *req;
|
|
struct pid *pid = get_pid(server->conn_pid);
|
|
int result = 0;
|
|
|
|
VERBOSE("state: %d\n", server->state);
|
|
if (server->state == CONN_VALID || server->state == CONN_RETRYING)
|
|
goto out;
|
|
|
|
smb_invalidate_inodes(server);
|
|
|
|
/*
|
|
* Some requests are meaningless after a retry, so we abort them.
|
|
* One example are all requests using 'fileid' since the files are
|
|
* closed on retry.
|
|
*/
|
|
head = server->xmitq.next;
|
|
while (head != &server->xmitq) {
|
|
req = list_entry(head, struct smb_request, rq_queue);
|
|
head = head->next;
|
|
|
|
req->rq_bytes_sent = 0;
|
|
if (req->rq_flags & SMB_REQ_NORETRY) {
|
|
VERBOSE("aborting request %p on xmitq\n", req);
|
|
req->rq_errno = -EIO;
|
|
list_del_init(&req->rq_queue);
|
|
smb_rput(req);
|
|
wake_up_interruptible(&req->rq_wait);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* FIXME: test the code for retrying request we already sent
|
|
*/
|
|
head = server->recvq.next;
|
|
while (head != &server->recvq) {
|
|
req = list_entry(head, struct smb_request, rq_queue);
|
|
head = head->next;
|
|
#if 0
|
|
if (req->rq_flags & SMB_REQ_RETRY) {
|
|
/* must move the request to the xmitq */
|
|
VERBOSE("retrying request %p on recvq\n", req);
|
|
list_move(&req->rq_queue, &server->xmitq);
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
VERBOSE("aborting request %p on recvq\n", req);
|
|
/* req->rq_rcls = ???; */ /* FIXME: set smb error code too? */
|
|
req->rq_errno = -EIO;
|
|
list_del_init(&req->rq_queue);
|
|
smb_rput(req);
|
|
wake_up_interruptible(&req->rq_wait);
|
|
}
|
|
|
|
smb_close_socket(server);
|
|
|
|
if (!pid) {
|
|
/* FIXME: this is fatal, umount? */
|
|
printk(KERN_ERR "smb_retry: no connection process\n");
|
|
server->state = CONN_RETRIED;
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* Change state so that only one retry per server will be started.
|
|
*/
|
|
server->state = CONN_RETRYING;
|
|
|
|
/*
|
|
* Note: use the "priv" flag, as a user process may need to reconnect.
|
|
*/
|
|
result = kill_pid(pid, SIGUSR1, 1);
|
|
if (result) {
|
|
/* FIXME: this is most likely fatal, umount? */
|
|
printk(KERN_ERR "smb_retry: signal failed [%d]\n", result);
|
|
goto out;
|
|
}
|
|
VERBOSE("signalled pid %d\n", pid_nr(pid));
|
|
|
|
/* FIXME: The retried requests should perhaps get a "time boost". */
|
|
|
|
out:
|
|
put_pid(pid);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Currently handles lockingX packets.
|
|
*/
|
|
static void smbiod_handle_request(struct smb_sb_info *server)
|
|
{
|
|
PARANOIA("smbiod got a request ... and we don't implement oplocks!\n");
|
|
server->rstate = SMB_RECV_DROP;
|
|
}
|
|
|
|
/*
|
|
* Do some IO for one server.
|
|
*/
|
|
static void smbiod_doio(struct smb_sb_info *server)
|
|
{
|
|
int result;
|
|
int maxwork = 7;
|
|
|
|
if (server->state != CONN_VALID)
|
|
goto out;
|
|
|
|
do {
|
|
result = smb_request_recv(server);
|
|
if (result < 0) {
|
|
server->state = CONN_INVALID;
|
|
smbiod_retry(server);
|
|
goto out; /* reconnecting is slow */
|
|
} else if (server->rstate == SMB_RECV_REQUEST)
|
|
smbiod_handle_request(server);
|
|
} while (result > 0 && maxwork-- > 0);
|
|
|
|
/*
|
|
* If there is more to read then we want to be sure to wake up again.
|
|
*/
|
|
if (server->state != CONN_VALID)
|
|
goto out;
|
|
if (smb_recv_available(server) > 0)
|
|
set_bit(SMBIOD_DATA_READY, &smbiod_flags);
|
|
|
|
do {
|
|
result = smb_request_send_server(server);
|
|
if (result < 0) {
|
|
server->state = CONN_INVALID;
|
|
smbiod_retry(server);
|
|
goto out; /* reconnecting is slow */
|
|
}
|
|
} while (result > 0);
|
|
|
|
/*
|
|
* If the last request was not sent out we want to wake up again.
|
|
*/
|
|
if (!list_empty(&server->xmitq))
|
|
set_bit(SMBIOD_DATA_READY, &smbiod_flags);
|
|
|
|
out:
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* smbiod kernel thread
|
|
*/
|
|
static int smbiod(void *unused)
|
|
{
|
|
VERBOSE("SMB Kernel thread starting (%d) ...\n", current->pid);
|
|
|
|
for (;;) {
|
|
struct smb_sb_info *server;
|
|
struct list_head *pos, *n;
|
|
|
|
/* FIXME: Use poll? */
|
|
wait_event_interruptible(smbiod_wait,
|
|
test_bit(SMBIOD_DATA_READY, &smbiod_flags));
|
|
if (signal_pending(current)) {
|
|
spin_lock(&servers_lock);
|
|
smbiod_state = SMBIOD_DEAD;
|
|
spin_unlock(&servers_lock);
|
|
break;
|
|
}
|
|
|
|
clear_bit(SMBIOD_DATA_READY, &smbiod_flags);
|
|
|
|
spin_lock(&servers_lock);
|
|
if (list_empty(&smb_servers)) {
|
|
smbiod_state = SMBIOD_DEAD;
|
|
spin_unlock(&servers_lock);
|
|
break;
|
|
}
|
|
|
|
list_for_each_safe(pos, n, &smb_servers) {
|
|
server = list_entry(pos, struct smb_sb_info, entry);
|
|
VERBOSE("checking server %p\n", server);
|
|
|
|
if (server->state == CONN_VALID) {
|
|
spin_unlock(&servers_lock);
|
|
|
|
smb_lock_server(server);
|
|
smbiod_doio(server);
|
|
smb_unlock_server(server);
|
|
|
|
spin_lock(&servers_lock);
|
|
}
|
|
}
|
|
spin_unlock(&servers_lock);
|
|
}
|
|
|
|
VERBOSE("SMB Kernel thread exiting (%d) ...\n", current->pid);
|
|
module_put_and_exit(0);
|
|
}
|