← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/staging/smbfs/smbiod.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/smbfs/smbiod.c
1
 
/*
2
 
 *  smbiod.c
3
 
 *
4
 
 *  Copyright (C) 2000, Charles Loep / Corel Corp.
5
 
 *  Copyright (C) 2001, Urban Widmark
6
 
 */
7
 
 
8
 
 
9
 
#include <linux/sched.h>
10
 
#include <linux/kernel.h>
11
 
#include <linux/mm.h>
12
 
#include <linux/string.h>
13
 
#include <linux/stat.h>
14
 
#include <linux/errno.h>
15
 
#include <linux/init.h>
16
 
#include <linux/file.h>
17
 
#include <linux/dcache.h>
18
 
#include <linux/module.h>
19
 
#include <linux/net.h>
20
 
#include <linux/kthread.h>
21
 
#include <net/ip.h>
22
 
 
23
 
#include <asm/system.h>
24
 
#include <asm/uaccess.h>
25
 
 
26
 
#include "smb_fs.h"
27
 
#include "smbno.h"
28
 
#include "smb_mount.h"
29
 
#include "smb_debug.h"
30
 
#include "request.h"
31
 
#include "proto.h"
32
 
 
33
 
enum smbiod_state {
34
 
        SMBIOD_DEAD,
35
 
        SMBIOD_STARTING,
36
 
        SMBIOD_RUNNING,
37
 
};
38
 
 
39
 
static enum smbiod_state smbiod_state = SMBIOD_DEAD;
40
 
static struct task_struct *smbiod_thread;
41
 
static DECLARE_WAIT_QUEUE_HEAD(smbiod_wait);
42
 
static LIST_HEAD(smb_servers);
43
 
static DEFINE_SPINLOCK(servers_lock);
44
 
 
45
 
#define SMBIOD_DATA_READY       (1<<0)
46
 
static unsigned long smbiod_flags;
47
 
 
48
 
static int smbiod(void *);
49
 
static int smbiod_start(void);
50
 
 
51
 
/*
52
 
 * called when there's work for us to do
53
 
 */
54
 
void smbiod_wake_up(void)
55
 
{
56
 
        if (smbiod_state == SMBIOD_DEAD)
57
 
                return;
58
 
        set_bit(SMBIOD_DATA_READY, &smbiod_flags);
59
 
        wake_up_interruptible(&smbiod_wait);
60
 
}
61
 
 
62
 
/*
63
 
 * start smbiod if none is running
64
 
 */
65
 
static int smbiod_start(void)
66
 
{
67
 
        struct task_struct *tsk;
68
 
        int err = 0;
69
 
 
70
 
        if (smbiod_state != SMBIOD_DEAD)
71
 
                return 0;
72
 
        smbiod_state = SMBIOD_STARTING;
73
 
        __module_get(THIS_MODULE);
74
 
        spin_unlock(&servers_lock);
75
 
        tsk = kthread_run(smbiod, NULL, "smbiod");
76
 
        if (IS_ERR(tsk)) {
77
 
                err = PTR_ERR(tsk);
78
 
                module_put(THIS_MODULE);
79
 
        }
80
 
 
81
 
        spin_lock(&servers_lock);
82
 
        if (err < 0) {
83
 
                smbiod_state = SMBIOD_DEAD;
84
 
                smbiod_thread = NULL;
85
 
        } else {
86
 
                smbiod_state = SMBIOD_RUNNING;
87
 
                smbiod_thread = tsk;
88
 
        }
89
 
        return err;
90
 
}
91
 
 
92
 
/*
93
 
 * register a server & start smbiod if necessary
94
 
 */
95
 
int smbiod_register_server(struct smb_sb_info *server)
96
 
{
97
 
        int ret;
98
 
        spin_lock(&servers_lock);
99
 
        list_add(&server->entry, &smb_servers);
100
 
        VERBOSE("%p\n", server);
101
 
        ret = smbiod_start();
102
 
        spin_unlock(&servers_lock);
103
 
        return ret;
104
 
}
105
 
 
106
 
/*
107
 
 * Unregister a server
108
 
 * Must be called with the server lock held.
109
 
 */
110
 
void smbiod_unregister_server(struct smb_sb_info *server)
111
 
{
112
 
        spin_lock(&servers_lock);
113
 
        list_del_init(&server->entry);
114
 
        VERBOSE("%p\n", server);
115
 
        spin_unlock(&servers_lock);
116
 
 
117
 
        smbiod_wake_up();
118
 
        smbiod_flush(server);
119
 
}
120
 
 
121
 
void smbiod_flush(struct smb_sb_info *server)
122
 
{
123
 
        struct list_head *tmp, *n;
124
 
        struct smb_request *req;
125
 
 
126
 
        list_for_each_safe(tmp, n, &server->xmitq) {
127
 
                req = list_entry(tmp, struct smb_request, rq_queue);
128
 
                req->rq_errno = -EIO;
129
 
                list_del_init(&req->rq_queue);
130
 
                smb_rput(req);
131
 
                wake_up_interruptible(&req->rq_wait);
132
 
        }
133
 
        list_for_each_safe(tmp, n, &server->recvq) {
134
 
                req = list_entry(tmp, struct smb_request, rq_queue);
135
 
                req->rq_errno = -EIO;
136
 
                list_del_init(&req->rq_queue);
137
 
                smb_rput(req);
138
 
                wake_up_interruptible(&req->rq_wait);
139
 
        }
140
 
}
141
 
 
142
 
/*
143
 
 * Wake up smbmount and make it reconnect to the server.
144
 
 * This must be called with the server locked.
145
 
 *
146
 
 * FIXME: add smbconnect version to this
147
 
 */
148
 
int smbiod_retry(struct smb_sb_info *server)
149
 
{
150
 
        struct list_head *head;
151
 
        struct smb_request *req;
152
 
        struct pid *pid = get_pid(server->conn_pid);
153
 
        int result = 0;
154
 
 
155
 
        VERBOSE("state: %d\n", server->state);
156
 
        if (server->state == CONN_VALID || server->state == CONN_RETRYING)
157
 
                goto out;
158
 
 
159
 
        smb_invalidate_inodes(server);
160
 
 
161
 
        /*
162
 
         * Some requests are meaningless after a retry, so we abort them.
163
 
         * One example are all requests using 'fileid' since the files are
164
 
         * closed on retry.
165
 
         */
166
 
        head = server->xmitq.next;
167
 
        while (head != &server->xmitq) {
168
 
                req = list_entry(head, struct smb_request, rq_queue);
169
 
                head = head->next;
170
 
 
171
 
                req->rq_bytes_sent = 0;
172
 
                if (req->rq_flags & SMB_REQ_NORETRY) {
173
 
                        VERBOSE("aborting request %p on xmitq\n", req);
174
 
                        req->rq_errno = -EIO;
175
 
                        list_del_init(&req->rq_queue);
176
 
                        smb_rput(req);
177
 
                        wake_up_interruptible(&req->rq_wait);
178
 
                }
179
 
        }
180
 
 
181
 
        /*
182
 
         * FIXME: test the code for retrying request we already sent
183
 
         */
184
 
        head = server->recvq.next;
185
 
        while (head != &server->recvq) {
186
 
                req = list_entry(head, struct smb_request, rq_queue);
187
 
                head = head->next;
188
 
#if 0
189
 
                if (req->rq_flags & SMB_REQ_RETRY) {
190
 
                        /* must move the request to the xmitq */
191
 
                        VERBOSE("retrying request %p on recvq\n", req);
192
 
                        list_move(&req->rq_queue, &server->xmitq);
193
 
                        continue;
194
 
                }
195
 
#endif
196
 
 
197
 
                VERBOSE("aborting request %p on recvq\n", req);
198
 
                /* req->rq_rcls = ???; */ /* FIXME: set smb error code too? */
199
 
                req->rq_errno = -EIO;
200
 
                list_del_init(&req->rq_queue);
201
 
                smb_rput(req);
202
 
                wake_up_interruptible(&req->rq_wait);
203
 
        }
204
 
 
205
 
        smb_close_socket(server);
206
 
 
207
 
        if (!pid) {
208
 
                /* FIXME: this is fatal, umount? */
209
 
                printk(KERN_ERR "smb_retry: no connection process\n");
210
 
                server->state = CONN_RETRIED;
211
 
                goto out;
212
 
        }
213
 
 
214
 
        /*
215
 
         * Change state so that only one retry per server will be started.
216
 
         */
217
 
        server->state = CONN_RETRYING;
218
 
 
219
 
        /*
220
 
         * Note: use the "priv" flag, as a user process may need to reconnect.
221
 
         */
222
 
        result = kill_pid(pid, SIGUSR1, 1);
223
 
        if (result) {
224
 
                /* FIXME: this is most likely fatal, umount? */
225
 
                printk(KERN_ERR "smb_retry: signal failed [%d]\n", result);
226
 
                goto out;
227
 
        }
228
 
        VERBOSE("signalled pid %d\n", pid_nr(pid));
229
 
 
230
 
        /* FIXME: The retried requests should perhaps get a "time boost". */
231
 
 
232
 
out:
233
 
        put_pid(pid);
234
 
        return result;
235
 
}
236
 
 
237
 
/*
238
 
 * Currently handles lockingX packets.
239
 
 */
240
 
static void smbiod_handle_request(struct smb_sb_info *server)
241
 
{
242
 
        PARANOIA("smbiod got a request ... and we don't implement oplocks!\n");
243
 
        server->rstate = SMB_RECV_DROP;
244
 
}
245
 
 
246
 
/*
247
 
 * Do some IO for one server.
248
 
 */
249
 
static void smbiod_doio(struct smb_sb_info *server)
250
 
{
251
 
        int result;
252
 
        int maxwork = 7;
253
 
 
254
 
        if (server->state != CONN_VALID)
255
 
                goto out;
256
 
 
257
 
        do {
258
 
                result = smb_request_recv(server);
259
 
                if (result < 0) {
260
 
                        server->state = CONN_INVALID;
261
 
                        smbiod_retry(server);
262
 
                        goto out;       /* reconnecting is slow */
263
 
                } else if (server->rstate == SMB_RECV_REQUEST)
264
 
                        smbiod_handle_request(server);
265
 
        } while (result > 0 && maxwork-- > 0);
266
 
 
267
 
        /*
268
 
         * If there is more to read then we want to be sure to wake up again.
269
 
         */
270
 
        if (server->state != CONN_VALID)
271
 
                goto out;
272
 
        if (smb_recv_available(server) > 0)
273
 
                set_bit(SMBIOD_DATA_READY, &smbiod_flags);
274
 
 
275
 
        do {
276
 
                result = smb_request_send_server(server);
277
 
                if (result < 0) {
278
 
                        server->state = CONN_INVALID;
279
 
                        smbiod_retry(server);
280
 
                        goto out;       /* reconnecting is slow */
281
 
                }
282
 
        } while (result > 0);
283
 
 
284
 
        /*
285
 
         * If the last request was not sent out we want to wake up again.
286
 
         */
287
 
        if (!list_empty(&server->xmitq))
288
 
                set_bit(SMBIOD_DATA_READY, &smbiod_flags);
289
 
 
290
 
out:
291
 
        return;
292
 
}
293
 
 
294
 
/*
295
 
 * smbiod kernel thread
296
 
 */
297
 
static int smbiod(void *unused)
298
 
{
299
 
        VERBOSE("SMB Kernel thread starting (%d) ...\n", current->pid);
300
 
 
301
 
        for (;;) {
302
 
                struct smb_sb_info *server;
303
 
                struct list_head *pos, *n;
304
 
 
305
 
                /* FIXME: Use poll? */
306
 
                wait_event_interruptible(smbiod_wait,
307
 
                         test_bit(SMBIOD_DATA_READY, &smbiod_flags));
308
 
                if (signal_pending(current)) {
309
 
                        spin_lock(&servers_lock);
310
 
                        smbiod_state = SMBIOD_DEAD;
311
 
                        spin_unlock(&servers_lock);
312
 
                        break;
313
 
                }
314
 
 
315
 
                clear_bit(SMBIOD_DATA_READY, &smbiod_flags);
316
 
 
317
 
                spin_lock(&servers_lock);
318
 
                if (list_empty(&smb_servers)) {
319
 
                        smbiod_state = SMBIOD_DEAD;
320
 
                        spin_unlock(&servers_lock);
321
 
                        break;
322
 
                }
323
 
 
324
 
                list_for_each_safe(pos, n, &smb_servers) {
325
 
                        server = list_entry(pos, struct smb_sb_info, entry);
326
 
                        VERBOSE("checking server %p\n", server);
327
 
 
328
 
                        if (server->state == CONN_VALID) {
329
 
                                spin_unlock(&servers_lock);
330
 
 
331
 
                                smb_lock_server(server);
332
 
                                smbiod_doio(server);
333
 
                                smb_unlock_server(server);
334
 
 
335
 
                                spin_lock(&servers_lock);
336
 
                        }
337
 
                }
338
 
                spin_unlock(&servers_lock);
339
 
        }
340
 
 
341
 
        VERBOSE("SMB Kernel thread exiting (%d) ...\n", current->pid);
342
 
        module_put_and_exit(0);
343
 
}