1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/*
* usema.c: software semaphore driver (see IRIX's usema(7M))
* written 1997 Mike Shaver (shaver@neon.ingenia.ca)
*
* This file contains the implementation of /dev/usema and /dev/usemaclone,
* the devices used by IRIX's us* semaphore routines.
*
* /dev/usemaclone is used to create a new semaphore device, and then
* the semaphore is manipulated via ioctls on /dev/usema. I'm sure
* it'll make more sense when I get it working. =) The devices are
* only accessed by the libc routines, apparently,
*
* At least for the zero-contention case, lock set and unset as well
* as semaphore P and V are done in userland, which makes things a
* little bit better. I suspect that the ioctls are used to register
* the process as blocking, etc.
*
* The minor number for the usema descriptor used to poll and block
* such determines which semaphore you're manipulating, so I think you're
* limited to (1 << MINORBITS - 1) semaphores active at a given time.
*
* Much inspiration and structure stolen from Miguel's shmiq work.
*
* For more information:
* usema(7m), usinit(3p), usnewsema(3p)
* /usr/include/sys/usioctl.h
*
*/
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <linux/sched.h>
#include <linux/file.h>
#include <linux/major.h>
#include <asm/smp_lock.h>
#include <asm/usioctl.h>
#include <asm/mman.h>
#define NUM_USEMAS (1 << MINORBITS - 1)
static struct irix_usema{
int used;
struct wait_queue *proc_list;
} usema_list[NUM_USEMAS];
/*
* Generate and return a descriptor for a new semaphore.
*/
static int
sgi_usemaclone_open(struct inode *inode, struct file *filp)
{
int semanum;
printk("[%s:%d] wants a new usema",
current->comm, current->pid);
for (semanum = 0;
semanum < NUM_USEMAS && !usema_list[semanum].used;
semanum++)
/* nothing */;
if (usema_list[semanum].used) {
printk("usemaclone: no more usemas left for process %d",
current->pid);
return -EBUSY;
}
/* XXX is this the right way to do it? */
inode->i_dev = MKDEV(USEMA_MAJOR, semanum);
usema_list[semanum].used = 1;
return 0;
}
/*
* Generate another descriptor for an existing semaphore.
*/
static int
sgi_usema_attach(usattach_t * attach, int semanum) {
int newfd;
/* create a new fd for this process with major/minor
correct, I guess. */
newfd = -ENOSYS;
return newfd;
}
static int
sgi_usema_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
int retval;
printk("[%s:%d] wants ioctl 0x%xd (arg 0x%xd)",
current->comm, current->pid, cmd, arg);
switch(cmd) {
case UIOCATTACHSEMA: {
/* They pass us information about the semaphore to
which they wish to be attached, and we create&return
a new fd corresponding to the appropriate semaphore.
*/
usattach_t *attach = (usattach_t *)arg;
int newfd;
int semanum;
retval = verify_area(VERIFY_READ, attach, sizeof(usattach_t));
if (retval) {
printk("[%s:%d] sgi_usema_ioctl(UIOATTACHSEMA): "
"verify_area failure",
current->comm, current->pid);
return retval;
}
semanum = MINOR(attach->us_dev);
if (semanum == 0) {
/* This shouldn't happen (tm).
A minor of zero indicates that there's no
semaphore created for the given descriptor...
in which case there's nothing to which to attach.
*/
return -EINVAL;
}
printk("UIOATTACHSEMA: attaching usema %d to process %d\n",
semanum, current->pid);
return sgi_usema_attach(attach, semanum);
break;
}
case UIOCBLOCK: {
/* Block this process on the semaphore */
/* I'll probably just pretend they're polling */
printk("UIOCBLOCK: (not) putting process %d to sleep",
current->pid);
}
case UIOCUNBLOCK: {
/* Wake up all process waiting on this semaphore */
}
return -ENOSYS;
}
static int
sgi_usema_poll(struct file *filp, poll_table *wait)
{
int semanum = MINOR(filp->f_dentry->d_inode->i_rdev);
printk("[%s:%d] wants to poll usema %d",
current->comm, current->pid, semanum);
/* I have to figure out what the behaviour is when:
- polling and the lock is free
- the lock becomes free and there's a process polling it
And I have to figure out the poll() semantics. =)
*/
return -ENOSYS;
}
struct file_operations sgi_usema_fops = {
NULL, /* llseek */
NULL, /* read */
NULL, /* write */
NULL, /* readdir */
sgi_usema_poll, /* poll */
sgi_usema_ioctl, /* ioctl */
NULL, /* mmap */
NULL, /* open */
NULL, /* release */
NULL, /* fsync */
NULL, /* check_media_change */
NULL, /* revalidate */
NULL /* lock */
};
struct file_operations sgi_usemaclone_fops = {
NULL, /* llseek */
NULL, /* read */
NULL, /* write */
NULL, /* readdir */
NULL, /* poll */
NULL, /* ioctl */
NULL, /* mmap */
sgi_usemaclone_open, /* open */
NULL, /* release */
NULL, /* fsync */
NULL, /* check_media_change */
NULL, /* revalidate */
NULL /* lock */
};
static struct miscdevice dev_usemaclone = {
SGI_USEMACLONE, "usemaclone", &sgi_usemaclone_fops
};
void
usema_init(void)
{
printk("usemaclone misc device registered (minor: %d)\n",
SGI_USEMACLONE);
misc_register(&dev_usemaclone);
register_chrdev(USEMA_MAJOR, "usema", &sgi_usema_fops);
printk("usema device registered (major %d)\n",
USEMA_MAJOR);
memset((void *)usema_list, 0, sizeof(struct irix_usema) * NUM_USEMAS);
}
|
