Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit a8147d737bd37bd51bb01737ac9c17a2cfc02a38

Authored by Joe Perches
Committed by David S. Miller
1 parent e956ea1b7d
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

net/atm/common.c: checkpatch cleanups 

Convert #include <asm... to #include <linux...
Move EXPORT_SYMBOL
Spacing cleanups
Use __func__ in printks
Indent switch/case statements
Move trailing statements to new line
Hoist assigns from if tests

Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 1 changed file with 173 additions and 165 deletions Inline Diff

1 /* net/atm/common.c - ATM sockets (common part for PVC and SVC) */ 1 /* net/atm/common.c - ATM sockets (common part for PVC and SVC) */
2 2
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */ 3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
4 4
5 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ 5 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
6 6
7 #include <linux/module.h> 7 #include <linux/module.h>
8 #include <linux/kmod.h> 8 #include <linux/kmod.h>
9 #include <linux/net.h> /* struct socket, struct proto_ops */ 9 #include <linux/net.h> /* struct socket, struct proto_ops */
10 #include <linux/atm.h> /* ATM stuff */ 10 #include <linux/atm.h> /* ATM stuff */
11 #include <linux/atmdev.h> 11 #include <linux/atmdev.h>
12 #include <linux/socket.h> /* SOL_SOCKET */ 12 #include <linux/socket.h> /* SOL_SOCKET */
13 #include <linux/errno.h> /* error codes */ 13 #include <linux/errno.h> /* error codes */
14 #include <linux/capability.h> 14 #include <linux/capability.h>
15 #include <linux/mm.h> 15 #include <linux/mm.h>
16 #include <linux/sched.h> 16 #include <linux/sched.h>
17 #include <linux/time.h> /* struct timeval */ 17 #include <linux/time.h> /* struct timeval */
18 #include <linux/skbuff.h> 18 #include <linux/skbuff.h>
19 #include <linux/bitops.h> 19 #include <linux/bitops.h>
20 #include <linux/init.h> 20 #include <linux/init.h>
21 #include <net/sock.h> /* struct sock */ 21 #include <net/sock.h> /* struct sock */
22 #include <linux/uaccess.h>
23 #include <linux/poll.h>
22 24
23 #include <asm/uaccess.h>
24 #include <asm/atomic.h> 25 #include <asm/atomic.h>
25 #include <asm/poll.h>
26 26
27
28 #include "resources.h" /* atm_find_dev */ 27 #include "resources.h" /* atm_find_dev */
29 #include "common.h" /* prototypes */ 28 #include "common.h" /* prototypes */
30 #include "protocols.h" /* atm_init_<transport> */ 29 #include "protocols.h" /* atm_init_<transport> */
31 #include "addr.h" /* address registry */ 30 #include "addr.h" /* address registry */
32 #include "signaling.h" /* for WAITING and sigd_attach */ 31 #include "signaling.h" /* for WAITING and sigd_attach */
33 32
34 struct hlist_head vcc_hash[VCC_HTABLE_SIZE]; 33 struct hlist_head vcc_hash[VCC_HTABLE_SIZE];
34 EXPORT_SYMBOL(vcc_hash);
35
35 DEFINE_RWLOCK(vcc_sklist_lock); 36 DEFINE_RWLOCK(vcc_sklist_lock);
37 EXPORT_SYMBOL(vcc_sklist_lock);
36 38
37 static void __vcc_insert_socket(struct sock *sk) 39 static void __vcc_insert_socket(struct sock *sk)
38 { 40 {
39 struct atm_vcc *vcc = atm_sk(sk); 41 struct atm_vcc *vcc = atm_sk(sk);
40 struct hlist_head *head = &vcc_hash[vcc->vci & 42 struct hlist_head *head = &vcc_hash[vcc->vci & (VCC_HTABLE_SIZE - 1)];
41 (VCC_HTABLE_SIZE - 1)];
42 sk->sk_hash = vcc->vci & (VCC_HTABLE_SIZE - 1); 43 sk->sk_hash = vcc->vci & (VCC_HTABLE_SIZE - 1);
43 sk_add_node(sk, head); 44 sk_add_node(sk, head);
44 } 45 }
45 46
46 void vcc_insert_socket(struct sock *sk) 47 void vcc_insert_socket(struct sock *sk)
47 { 48 {
48 write_lock_irq(&vcc_sklist_lock); 49 write_lock_irq(&vcc_sklist_lock);
49 __vcc_insert_socket(sk); 50 __vcc_insert_socket(sk);
50 write_unlock_irq(&vcc_sklist_lock); 51 write_unlock_irq(&vcc_sklist_lock);
51 } 52 }
53 EXPORT_SYMBOL(vcc_insert_socket);
52 54
53 static void vcc_remove_socket(struct sock *sk) 55 static void vcc_remove_socket(struct sock *sk)
54 { 56 {
55 write_lock_irq(&vcc_sklist_lock); 57 write_lock_irq(&vcc_sklist_lock);
56 sk_del_node_init(sk); 58 sk_del_node_init(sk);
57 write_unlock_irq(&vcc_sklist_lock); 59 write_unlock_irq(&vcc_sklist_lock);
58 } 60 }
59 61
60 62 static struct sk_buff *alloc_tx(struct atm_vcc *vcc, unsigned int size)
61 static struct sk_buff *alloc_tx(struct atm_vcc *vcc,unsigned int size)
62 { 63 {
63 struct sk_buff *skb; 64 struct sk_buff *skb;
64 struct sock *sk = sk_atm(vcc); 65 struct sock *sk = sk_atm(vcc);
65 66
66 if (sk_wmem_alloc_get(sk) && !atm_may_send(vcc, size)) { 67 if (sk_wmem_alloc_get(sk) && !atm_may_send(vcc, size)) {
67 pr_debug("Sorry: wmem_alloc = %d, size = %d, sndbuf = %d\n", 68 pr_debug("Sorry: wmem_alloc = %d, size = %d, sndbuf = %d\n",
68 sk_wmem_alloc_get(sk), size, sk->sk_sndbuf); 69 sk_wmem_alloc_get(sk), size, sk->sk_sndbuf);
69 return NULL; 70 return NULL;
70 } 71 }
71 while (!(skb = alloc_skb(size, GFP_KERNEL))) 72 while (!(skb = alloc_skb(size, GFP_KERNEL)))
72 schedule(); 73 schedule();
73 pr_debug("AlTx %d += %d\n", sk_wmem_alloc_get(sk), skb->truesize); 74 pr_debug("%d += %d\n", sk_wmem_alloc_get(sk), skb->truesize);
74 atomic_add(skb->truesize, &sk->sk_wmem_alloc); 75 atomic_add(skb->truesize, &sk->sk_wmem_alloc);
75 return skb; 76 return skb;
76 } 77 }
77 78
78
79 EXPORT_SYMBOL(vcc_hash);
80 EXPORT_SYMBOL(vcc_sklist_lock);
81 EXPORT_SYMBOL(vcc_insert_socket);
82
83 static void vcc_sock_destruct(struct sock *sk) 79 static void vcc_sock_destruct(struct sock *sk)
84 { 80 {
85 if (atomic_read(&sk->sk_rmem_alloc)) 81 if (atomic_read(&sk->sk_rmem_alloc))
86 printk(KERN_DEBUG "vcc_sock_destruct: rmem leakage (%d bytes) detected.\n", atomic_read(&sk->sk_rmem_alloc)); 82 printk(KERN_DEBUG "%s: rmem leakage (%d bytes) detected.\n",
83 __func__, atomic_read(&sk->sk_rmem_alloc));
87 84
88 if (atomic_read(&sk->sk_wmem_alloc)) 85 if (atomic_read(&sk->sk_wmem_alloc))
89 printk(KERN_DEBUG "vcc_sock_destruct: wmem leakage (%d bytes) detected.\n", atomic_read(&sk->sk_wmem_alloc)); 86 printk(KERN_DEBUG "%s: wmem leakage (%d bytes) detected.\n",
87 __func__, atomic_read(&sk->sk_wmem_alloc));
90 } 88 }
91 89
92 static void vcc_def_wakeup(struct sock *sk) 90 static void vcc_def_wakeup(struct sock *sk)
93 { 91 {
94 read_lock(&sk->sk_callback_lock); 92 read_lock(&sk->sk_callback_lock);
95 if (sk_has_sleeper(sk)) 93 if (sk_has_sleeper(sk))
96 wake_up(sk->sk_sleep); 94 wake_up(sk->sk_sleep);
97 read_unlock(&sk->sk_callback_lock); 95 read_unlock(&sk->sk_callback_lock);
98 } 96 }
99 97
100 static inline int vcc_writable(struct sock *sk) 98 static inline int vcc_writable(struct sock *sk)
101 { 99 {
102 struct atm_vcc *vcc = atm_sk(sk); 100 struct atm_vcc *vcc = atm_sk(sk);
103 101
104 return (vcc->qos.txtp.max_sdu + 102 return (vcc->qos.txtp.max_sdu +
105 atomic_read(&sk->sk_wmem_alloc)) <= sk->sk_sndbuf; 103 atomic_read(&sk->sk_wmem_alloc)) <= sk->sk_sndbuf;
106 } 104 }
107 105
108 static void vcc_write_space(struct sock *sk) 106 static void vcc_write_space(struct sock *sk)
109 { 107 {
110 read_lock(&sk->sk_callback_lock); 108 read_lock(&sk->sk_callback_lock);
111 109
112 if (vcc_writable(sk)) { 110 if (vcc_writable(sk)) {
113 if (sk_has_sleeper(sk)) 111 if (sk_has_sleeper(sk))
114 wake_up_interruptible(sk->sk_sleep); 112 wake_up_interruptible(sk->sk_sleep);
115 113
116 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT); 114 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
117 } 115 }
118 116
119 read_unlock(&sk->sk_callback_lock); 117 read_unlock(&sk->sk_callback_lock);
120 } 118 }
121 119
122 static struct proto vcc_proto = { 120 static struct proto vcc_proto = {
123 .name = "VCC", 121 .name = "VCC",
124 .owner = THIS_MODULE, 122 .owner = THIS_MODULE,
125 .obj_size = sizeof(struct atm_vcc), 123 .obj_size = sizeof(struct atm_vcc),
126 }; 124 };
127 125
128 int vcc_create(struct net *net, struct socket *sock, int protocol, int family) 126 int vcc_create(struct net *net, struct socket *sock, int protocol, int family)
129 { 127 {
130 struct sock *sk; 128 struct sock *sk;
131 struct atm_vcc *vcc; 129 struct atm_vcc *vcc;
132 130
133 sock->sk = NULL; 131 sock->sk = NULL;
134 if (sock->type == SOCK_STREAM) 132 if (sock->type == SOCK_STREAM)
135 return -EINVAL; 133 return -EINVAL;
136 sk = sk_alloc(net, family, GFP_KERNEL, &vcc_proto); 134 sk = sk_alloc(net, family, GFP_KERNEL, &vcc_proto);
137 if (!sk) 135 if (!sk)
138 return -ENOMEM; 136 return -ENOMEM;
139 sock_init_data(sock, sk); 137 sock_init_data(sock, sk);
140 sk->sk_state_change = vcc_def_wakeup; 138 sk->sk_state_change = vcc_def_wakeup;
141 sk->sk_write_space = vcc_write_space; 139 sk->sk_write_space = vcc_write_space;
142 140
143 vcc = atm_sk(sk); 141 vcc = atm_sk(sk);
144 vcc->dev = NULL; 142 vcc->dev = NULL;
145 memset(&vcc->local,0,sizeof(struct sockaddr_atmsvc)); 143 memset(&vcc->local, 0, sizeof(struct sockaddr_atmsvc));
146 memset(&vcc->remote,0,sizeof(struct sockaddr_atmsvc)); 144 memset(&vcc->remote, 0, sizeof(struct sockaddr_atmsvc));
147 vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */ 145 vcc->qos.txtp.max_sdu = 1 << 16; /* for meta VCs */
148 atomic_set(&sk->sk_wmem_alloc, 1); 146 atomic_set(&sk->sk_wmem_alloc, 1);
149 atomic_set(&sk->sk_rmem_alloc, 0); 147 atomic_set(&sk->sk_rmem_alloc, 0);
150 vcc->push = NULL; 148 vcc->push = NULL;
151 vcc->pop = NULL; 149 vcc->pop = NULL;
152 vcc->push_oam = NULL; 150 vcc->push_oam = NULL;
153 vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */ 151 vcc->vpi = vcc->vci = 0; /* no VCI/VPI yet */
154 vcc->atm_options = vcc->aal_options = 0; 152 vcc->atm_options = vcc->aal_options = 0;
155 sk->sk_destruct = vcc_sock_destruct; 153 sk->sk_destruct = vcc_sock_destruct;
156 return 0; 154 return 0;
157 } 155 }
158 156
159
160 static void vcc_destroy_socket(struct sock *sk) 157 static void vcc_destroy_socket(struct sock *sk)
161 { 158 {
162 struct atm_vcc *vcc = atm_sk(sk); 159 struct atm_vcc *vcc = atm_sk(sk);
163 struct sk_buff *skb; 160 struct sk_buff *skb;
164 161
165 set_bit(ATM_VF_CLOSE, &vcc->flags); 162 set_bit(ATM_VF_CLOSE, &vcc->flags);
166 clear_bit(ATM_VF_READY, &vcc->flags); 163 clear_bit(ATM_VF_READY, &vcc->flags);
167 if (vcc->dev) { 164 if (vcc->dev) {
168 if (vcc->dev->ops->close) 165 if (vcc->dev->ops->close)
169 vcc->dev->ops->close(vcc); 166 vcc->dev->ops->close(vcc);
170 if (vcc->push) 167 if (vcc->push)
171 vcc->push(vcc, NULL); /* atmarpd has no push */ 168 vcc->push(vcc, NULL); /* atmarpd has no push */
172 169
173 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) { 170 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
174 atm_return(vcc,skb->truesize); 171 atm_return(vcc, skb->truesize);
175 kfree_skb(skb); 172 kfree_skb(skb);
176 } 173 }
177 174
178 module_put(vcc->dev->ops->owner); 175 module_put(vcc->dev->ops->owner);
179 atm_dev_put(vcc->dev); 176 atm_dev_put(vcc->dev);
180 } 177 }
181 178
182 vcc_remove_socket(sk); 179 vcc_remove_socket(sk);
183 } 180 }
184 181
185
186 int vcc_release(struct socket *sock) 182 int vcc_release(struct socket *sock)
187 { 183 {
188 struct sock *sk = sock->sk; 184 struct sock *sk = sock->sk;
189 185
190 if (sk) { 186 if (sk) {
191 lock_sock(sk); 187 lock_sock(sk);
192 vcc_destroy_socket(sock->sk); 188 vcc_destroy_socket(sock->sk);
193 release_sock(sk); 189 release_sock(sk);
194 sock_put(sk); 190 sock_put(sk);
195 } 191 }
196 192
197 return 0; 193 return 0;
198 } 194 }
199 195
200
201 void vcc_release_async(struct atm_vcc *vcc, int reply) 196 void vcc_release_async(struct atm_vcc *vcc, int reply)
202 { 197 {
203 struct sock *sk = sk_atm(vcc); 198 struct sock *sk = sk_atm(vcc);
204 199
205 set_bit(ATM_VF_CLOSE, &vcc->flags); 200 set_bit(ATM_VF_CLOSE, &vcc->flags);
206 sk->sk_shutdown |= RCV_SHUTDOWN; 201 sk->sk_shutdown |= RCV_SHUTDOWN;
207 sk->sk_err = -reply; 202 sk->sk_err = -reply;
208 clear_bit(ATM_VF_WAITING, &vcc->flags); 203 clear_bit(ATM_VF_WAITING, &vcc->flags);
209 sk->sk_state_change(sk); 204 sk->sk_state_change(sk);
210 } 205 }
211
212
213 EXPORT_SYMBOL(vcc_release_async); 206 EXPORT_SYMBOL(vcc_release_async);
214 207
215 208
216 void atm_dev_release_vccs(struct atm_dev *dev) 209 void atm_dev_release_vccs(struct atm_dev *dev)
217 { 210 {
218 int i; 211 int i;
219 212
220 write_lock_irq(&vcc_sklist_lock); 213 write_lock_irq(&vcc_sklist_lock);
221 for (i = 0; i < VCC_HTABLE_SIZE; i++) { 214 for (i = 0; i < VCC_HTABLE_SIZE; i++) {
222 struct hlist_head *head = &vcc_hash[i]; 215 struct hlist_head *head = &vcc_hash[i];
223 struct hlist_node *node, *tmp; 216 struct hlist_node *node, *tmp;
224 struct sock *s; 217 struct sock *s;
225 struct atm_vcc *vcc; 218 struct atm_vcc *vcc;
226 219
227 sk_for_each_safe(s, node, tmp, head) { 220 sk_for_each_safe(s, node, tmp, head) {
228 vcc = atm_sk(s); 221 vcc = atm_sk(s);
229 if (vcc->dev == dev) { 222 if (vcc->dev == dev) {
230 vcc_release_async(vcc, -EPIPE); 223 vcc_release_async(vcc, -EPIPE);
231 sk_del_node_init(s); 224 sk_del_node_init(s);
232 } 225 }
233 } 226 }
234 } 227 }
235 write_unlock_irq(&vcc_sklist_lock); 228 write_unlock_irq(&vcc_sklist_lock);
236 } 229 }
237 230
238 231 static int adjust_tp(struct atm_trafprm *tp, unsigned char aal)
239 static int adjust_tp(struct atm_trafprm *tp,unsigned char aal)
240 { 232 {
241 int max_sdu; 233 int max_sdu;
242 234
243 if (!tp->traffic_class) return 0; 235 if (!tp->traffic_class)
236 return 0;
244 switch (aal) { 237 switch (aal) {
245 case ATM_AAL0: 238 case ATM_AAL0:
246 max_sdu = ATM_CELL_SIZE-1; 239 max_sdu = ATM_CELL_SIZE-1;
247 break; 240 break;
248 case ATM_AAL34: 241 case ATM_AAL34:
249 max_sdu = ATM_MAX_AAL34_PDU; 242 max_sdu = ATM_MAX_AAL34_PDU;
250 break; 243 break;
251 default: 244 default:
252 pr_warning("AAL problems ... (%d)\n", aal); 245 pr_warning("AAL problems ... (%d)\n", aal);
253 /* fall through */ 246 /* fall through */
254 case ATM_AAL5: 247 case ATM_AAL5:
255 max_sdu = ATM_MAX_AAL5_PDU; 248 max_sdu = ATM_MAX_AAL5_PDU;
256 } 249 }
257 if (!tp->max_sdu) tp->max_sdu = max_sdu; 250 if (!tp->max_sdu)
258 else if (tp->max_sdu > max_sdu) return -EINVAL; 251 tp->max_sdu = max_sdu;
259 if (!tp->max_cdv) tp->max_cdv = ATM_MAX_CDV; 252 else if (tp->max_sdu > max_sdu)
253 return -EINVAL;
254 if (!tp->max_cdv)
255 tp->max_cdv = ATM_MAX_CDV;
260 return 0; 256 return 0;
261 } 257 }
262 258
263
264 static int check_ci(const struct atm_vcc *vcc, short vpi, int vci) 259 static int check_ci(const struct atm_vcc *vcc, short vpi, int vci)
265 { 260 {
266 struct hlist_head *head = &vcc_hash[vci & 261 struct hlist_head *head = &vcc_hash[vci & (VCC_HTABLE_SIZE - 1)];
267 (VCC_HTABLE_SIZE - 1)];
268 struct hlist_node *node; 262 struct hlist_node *node;
269 struct sock *s; 263 struct sock *s;
270 struct atm_vcc *walk; 264 struct atm_vcc *walk;
271 265
272 sk_for_each(s, node, head) { 266 sk_for_each(s, node, head) {
273 walk = atm_sk(s); 267 walk = atm_sk(s);
274 if (walk->dev != vcc->dev) 268 if (walk->dev != vcc->dev)
275 continue; 269 continue;
276 if (test_bit(ATM_VF_ADDR, &walk->flags) && walk->vpi == vpi && 270 if (test_bit(ATM_VF_ADDR, &walk->flags) && walk->vpi == vpi &&
277 walk->vci == vci && ((walk->qos.txtp.traffic_class != 271 walk->vci == vci && ((walk->qos.txtp.traffic_class !=
278 ATM_NONE && vcc->qos.txtp.traffic_class != ATM_NONE) || 272 ATM_NONE && vcc->qos.txtp.traffic_class != ATM_NONE) ||
279 (walk->qos.rxtp.traffic_class != ATM_NONE && 273 (walk->qos.rxtp.traffic_class != ATM_NONE &&
280 vcc->qos.rxtp.traffic_class != ATM_NONE))) 274 vcc->qos.rxtp.traffic_class != ATM_NONE)))
281 return -EADDRINUSE; 275 return -EADDRINUSE;
282 } 276 }
283 277
284 /* allow VCCs with same VPI/VCI iff they don't collide on 278 /* allow VCCs with same VPI/VCI iff they don't collide on
285 TX/RX (but we may refuse such sharing for other reasons, 279 TX/RX (but we may refuse such sharing for other reasons,
286 e.g. if protocol requires to have both channels) */ 280 e.g. if protocol requires to have both channels) */
287 281
288 return 0; 282 return 0;
289 } 283 }
290 284
291
292 static int find_ci(const struct atm_vcc *vcc, short *vpi, int *vci) 285 static int find_ci(const struct atm_vcc *vcc, short *vpi, int *vci)
293 { 286 {
294 static short p; /* poor man's per-device cache */ 287 static short p; /* poor man's per-device cache */
295 static int c; 288 static int c;
296 short old_p; 289 short old_p;
297 int old_c; 290 int old_c;
298 int err; 291 int err;
299 292
300 if (*vpi != ATM_VPI_ANY && *vci != ATM_VCI_ANY) { 293 if (*vpi != ATM_VPI_ANY && *vci != ATM_VCI_ANY) {
301 err = check_ci(vcc, *vpi, *vci); 294 err = check_ci(vcc, *vpi, *vci);
302 return err; 295 return err;
303 } 296 }
304 /* last scan may have left values out of bounds for current device */ 297 /* last scan may have left values out of bounds for current device */
305 if (*vpi != ATM_VPI_ANY) 298 if (*vpi != ATM_VPI_ANY)
306 p = *vpi; 299 p = *vpi;
307 else if (p >= 1 << vcc->dev->ci_range.vpi_bits) 300 else if (p >= 1 << vcc->dev->ci_range.vpi_bits)
308 p = 0; 301 p = 0;
309 if (*vci != ATM_VCI_ANY) 302 if (*vci != ATM_VCI_ANY)
310 c = *vci; 303 c = *vci;
311 else if (c < ATM_NOT_RSV_VCI || c >= 1 << vcc->dev->ci_range.vci_bits) 304 else if (c < ATM_NOT_RSV_VCI || c >= 1 << vcc->dev->ci_range.vci_bits)
312 c = ATM_NOT_RSV_VCI; 305 c = ATM_NOT_RSV_VCI;
313 old_p = p; 306 old_p = p;
314 old_c = c; 307 old_c = c;
315 do { 308 do {
316 if (!check_ci(vcc, p, c)) { 309 if (!check_ci(vcc, p, c)) {
317 *vpi = p; 310 *vpi = p;
318 *vci = c; 311 *vci = c;
319 return 0; 312 return 0;
320 } 313 }
321 if (*vci == ATM_VCI_ANY) { 314 if (*vci == ATM_VCI_ANY) {
322 c++; 315 c++;
323 if (c >= 1 << vcc->dev->ci_range.vci_bits) 316 if (c >= 1 << vcc->dev->ci_range.vci_bits)
324 c = ATM_NOT_RSV_VCI; 317 c = ATM_NOT_RSV_VCI;
325 } 318 }
326 if ((c == ATM_NOT_RSV_VCI || *vci != ATM_VCI_ANY) && 319 if ((c == ATM_NOT_RSV_VCI || *vci != ATM_VCI_ANY) &&
327 *vpi == ATM_VPI_ANY) { 320 *vpi == ATM_VPI_ANY) {
328 p++; 321 p++;
329 if (p >= 1 << vcc->dev->ci_range.vpi_bits) p = 0; 322 if (p >= 1 << vcc->dev->ci_range.vpi_bits)
323 p = 0;
330 } 324 }
331 } 325 } while (old_p != p || old_c != c);
332 while (old_p != p || old_c != c);
333 return -EADDRINUSE; 326 return -EADDRINUSE;
334 } 327 }
335 328
336
337 static int __vcc_connect(struct atm_vcc *vcc, struct atm_dev *dev, short vpi, 329 static int __vcc_connect(struct atm_vcc *vcc, struct atm_dev *dev, short vpi,
338 int vci) 330 int vci)
339 { 331 {
340 struct sock *sk = sk_atm(vcc); 332 struct sock *sk = sk_atm(vcc);
341 int error; 333 int error;
342 334
343 if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY && 335 if ((vpi != ATM_VPI_UNSPEC && vpi != ATM_VPI_ANY &&
344 vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC && 336 vpi >> dev->ci_range.vpi_bits) || (vci != ATM_VCI_UNSPEC &&
345 vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits)) 337 vci != ATM_VCI_ANY && vci >> dev->ci_range.vci_bits))
346 return -EINVAL; 338 return -EINVAL;
347 if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE)) 339 if (vci > 0 && vci < ATM_NOT_RSV_VCI && !capable(CAP_NET_BIND_SERVICE))
348 return -EPERM; 340 return -EPERM;
349 error = -ENODEV; 341 error = -ENODEV;
350 if (!try_module_get(dev->ops->owner)) 342 if (!try_module_get(dev->ops->owner))
351 return error; 343 return error;
352 vcc->dev = dev; 344 vcc->dev = dev;
353 write_lock_irq(&vcc_sklist_lock); 345 write_lock_irq(&vcc_sklist_lock);
354 if (test_bit(ATM_DF_REMOVED, &dev->flags) || 346 if (test_bit(ATM_DF_REMOVED, &dev->flags) ||
355 (error = find_ci(vcc, &vpi, &vci))) { 347 (error = find_ci(vcc, &vpi, &vci))) {
356 write_unlock_irq(&vcc_sklist_lock); 348 write_unlock_irq(&vcc_sklist_lock);
357 goto fail_module_put; 349 goto fail_module_put;
358 } 350 }
359 vcc->vpi = vpi; 351 vcc->vpi = vpi;
360 vcc->vci = vci; 352 vcc->vci = vci;
361 __vcc_insert_socket(sk); 353 __vcc_insert_socket(sk);
362 write_unlock_irq(&vcc_sklist_lock); 354 write_unlock_irq(&vcc_sklist_lock);
363 switch (vcc->qos.aal) { 355 switch (vcc->qos.aal) {
364 case ATM_AAL0: 356 case ATM_AAL0:
365 error = atm_init_aal0(vcc); 357 error = atm_init_aal0(vcc);
366 vcc->stats = &dev->stats.aal0; 358 vcc->stats = &dev->stats.aal0;
367 break; 359 break;
368 case ATM_AAL34: 360 case ATM_AAL34:
369 error = atm_init_aal34(vcc); 361 error = atm_init_aal34(vcc);
370 vcc->stats = &dev->stats.aal34; 362 vcc->stats = &dev->stats.aal34;
371 break; 363 break;
372 case ATM_NO_AAL: 364 case ATM_NO_AAL:
373 /* ATM_AAL5 is also used in the "0 for default" case */ 365 /* ATM_AAL5 is also used in the "0 for default" case */
374 vcc->qos.aal = ATM_AAL5; 366 vcc->qos.aal = ATM_AAL5;
375 /* fall through */ 367 /* fall through */
376 case ATM_AAL5: 368 case ATM_AAL5:
377 error = atm_init_aal5(vcc); 369 error = atm_init_aal5(vcc);
378 vcc->stats = &dev->stats.aal5; 370 vcc->stats = &dev->stats.aal5;
379 break; 371 break;
380 default: 372 default:
381 error = -EPROTOTYPE; 373 error = -EPROTOTYPE;
382 } 374 }
383 if (!error) error = adjust_tp(&vcc->qos.txtp,vcc->qos.aal); 375 if (!error)
384 if (!error) error = adjust_tp(&vcc->qos.rxtp,vcc->qos.aal); 376 error = adjust_tp(&vcc->qos.txtp, vcc->qos.aal);
377 if (!error)
378 error = adjust_tp(&vcc->qos.rxtp, vcc->qos.aal);
385 if (error) 379 if (error)
386 goto fail; 380 goto fail;
387 pr_debug("VCC %d.%d, AAL %d\n", vpi, vci, vcc->qos.aal); 381 pr_debug("VCC %d.%d, AAL %d\n", vpi, vci, vcc->qos.aal);
388 pr_debug(" TX: %d, PCR %d..%d, SDU %d\n", 382 pr_debug(" TX: %d, PCR %d..%d, SDU %d\n",
389 vcc->qos.txtp.traffic_class, 383 vcc->qos.txtp.traffic_class,
390 vcc->qos.txtp.min_pcr, 384 vcc->qos.txtp.min_pcr,
391 vcc->qos.txtp.max_pcr, 385 vcc->qos.txtp.max_pcr,
392 vcc->qos.txtp.max_sdu); 386 vcc->qos.txtp.max_sdu);
393 pr_debug(" RX: %d, PCR %d..%d, SDU %d\n", 387 pr_debug(" RX: %d, PCR %d..%d, SDU %d\n",
394 vcc->qos.rxtp.traffic_class, 388 vcc->qos.rxtp.traffic_class,
395 vcc->qos.rxtp.min_pcr, 389 vcc->qos.rxtp.min_pcr,
396 vcc->qos.rxtp.max_pcr, 390 vcc->qos.rxtp.max_pcr,
397 vcc->qos.rxtp.max_sdu); 391 vcc->qos.rxtp.max_sdu);
398 392
399 if (dev->ops->open) { 393 if (dev->ops->open) {
400 if ((error = dev->ops->open(vcc))) 394 error = dev->ops->open(vcc);
395 if (error)
401 goto fail; 396 goto fail;
402 } 397 }
403 return 0; 398 return 0;
404 399
405 fail: 400 fail:
406 vcc_remove_socket(sk); 401 vcc_remove_socket(sk);
407 fail_module_put: 402 fail_module_put:
408 module_put(dev->ops->owner); 403 module_put(dev->ops->owner);
409 /* ensure we get dev module ref count correct */ 404 /* ensure we get dev module ref count correct */
410 vcc->dev = NULL; 405 vcc->dev = NULL;
411 return error; 406 return error;
412 } 407 }
413 408
414
415 int vcc_connect(struct socket *sock, int itf, short vpi, int vci) 409 int vcc_connect(struct socket *sock, int itf, short vpi, int vci)
416 { 410 {
417 struct atm_dev *dev; 411 struct atm_dev *dev;
418 struct atm_vcc *vcc = ATM_SD(sock); 412 struct atm_vcc *vcc = ATM_SD(sock);
419 int error; 413 int error;
420 414
421 pr_debug("(vpi %d, vci %d)\n", vpi, vci); 415 pr_debug("(vpi %d, vci %d)\n", vpi, vci);
422 if (sock->state == SS_CONNECTED) 416 if (sock->state == SS_CONNECTED)
423 return -EISCONN; 417 return -EISCONN;
424 if (sock->state != SS_UNCONNECTED) 418 if (sock->state != SS_UNCONNECTED)
425 return -EINVAL; 419 return -EINVAL;
426 if (!(vpi || vci)) 420 if (!(vpi || vci))
427 return -EINVAL; 421 return -EINVAL;
428 422
429 if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC) 423 if (vpi != ATM_VPI_UNSPEC && vci != ATM_VCI_UNSPEC)
430 clear_bit(ATM_VF_PARTIAL,&vcc->flags); 424 clear_bit(ATM_VF_PARTIAL, &vcc->flags);
431 else 425 else
432 if (test_bit(ATM_VF_PARTIAL,&vcc->flags)) 426 if (test_bit(ATM_VF_PARTIAL, &vcc->flags))
433 return -EINVAL; 427 return -EINVAL;
434 pr_debug("(TX: cl %d,bw %d-%d,sdu %d; " 428 pr_debug("(TX: cl %d,bw %d-%d,sdu %d; "
435 "RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)\n", 429 "RX: cl %d,bw %d-%d,sdu %d,AAL %s%d)\n",
436 vcc->qos.txtp.traffic_class, vcc->qos.txtp.min_pcr, 430 vcc->qos.txtp.traffic_class, vcc->qos.txtp.min_pcr,
437 vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_sdu, 431 vcc->qos.txtp.max_pcr, vcc->qos.txtp.max_sdu,
438 vcc->qos.rxtp.traffic_class, vcc->qos.rxtp.min_pcr, 432 vcc->qos.rxtp.traffic_class, vcc->qos.rxtp.min_pcr,
439 vcc->qos.rxtp.max_pcr,vcc->qos.rxtp.max_sdu, 433 vcc->qos.rxtp.max_pcr, vcc->qos.rxtp.max_sdu,
440 vcc->qos.aal == ATM_AAL5 ? "" : 434 vcc->qos.aal == ATM_AAL5 ? "" :
441 vcc->qos.aal == ATM_AAL0 ? "" : " ??? code ", 435 vcc->qos.aal == ATM_AAL0 ? "" : " ??? code ",
442 vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal); 436 vcc->qos.aal == ATM_AAL0 ? 0 : vcc->qos.aal);
443 if (!test_bit(ATM_VF_HASQOS, &vcc->flags)) 437 if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
444 return -EBADFD; 438 return -EBADFD;
445 if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS || 439 if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
446 vcc->qos.rxtp.traffic_class == ATM_ANYCLASS) 440 vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
447 return -EINVAL; 441 return -EINVAL;
448 if (likely(itf != ATM_ITF_ANY)) { 442 if (likely(itf != ATM_ITF_ANY)) {
449 dev = try_then_request_module(atm_dev_lookup(itf), "atm-device-%d", itf); 443 dev = try_then_request_module(atm_dev_lookup(itf),
444 "atm-device-%d", itf);
450 } else { 445 } else {
451 dev = NULL; 446 dev = NULL;
452 mutex_lock(&atm_dev_mutex); 447 mutex_lock(&atm_dev_mutex);
453 if (!list_empty(&atm_devs)) { 448 if (!list_empty(&atm_devs)) {
454 dev = list_entry(atm_devs.next, struct atm_dev, dev_list); 449 dev = list_entry(atm_devs.next,
450 struct atm_dev, dev_list);
455 atm_dev_hold(dev); 451 atm_dev_hold(dev);
456 } 452 }
457 mutex_unlock(&atm_dev_mutex); 453 mutex_unlock(&atm_dev_mutex);
458 } 454 }
459 if (!dev) 455 if (!dev)
460 return -ENODEV; 456 return -ENODEV;
461 error = __vcc_connect(vcc, dev, vpi, vci); 457 error = __vcc_connect(vcc, dev, vpi, vci);
462 if (error) { 458 if (error) {
463 atm_dev_put(dev); 459 atm_dev_put(dev);
464 return error; 460 return error;
465 } 461 }
466 if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC) 462 if (vpi == ATM_VPI_UNSPEC || vci == ATM_VCI_UNSPEC)
467 set_bit(ATM_VF_PARTIAL,&vcc->flags); 463 set_bit(ATM_VF_PARTIAL, &vcc->flags);
468 if (test_bit(ATM_VF_READY,&ATM_SD(sock)->flags)) 464 if (test_bit(ATM_VF_READY, &ATM_SD(sock)->flags))
469 sock->state = SS_CONNECTED; 465 sock->state = SS_CONNECTED;
470 return 0; 466 return 0;
471 } 467 }
472 468
473
474 int vcc_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, 469 int vcc_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
475 size_t size, int flags) 470 size_t size, int flags)
476 { 471 {
477 struct sock *sk = sock->sk; 472 struct sock *sk = sock->sk;
478 struct atm_vcc *vcc; 473 struct atm_vcc *vcc;
479 struct sk_buff *skb; 474 struct sk_buff *skb;
480 int copied, error = -EINVAL; 475 int copied, error = -EINVAL;
481 476
482 if (sock->state != SS_CONNECTED) 477 if (sock->state != SS_CONNECTED)
483 return -ENOTCONN; 478 return -ENOTCONN;
484 if (flags & ~MSG_DONTWAIT) /* only handle MSG_DONTWAIT */ 479 if (flags & ~MSG_DONTWAIT) /* only handle MSG_DONTWAIT */
485 return -EOPNOTSUPP; 480 return -EOPNOTSUPP;
486 vcc = ATM_SD(sock); 481 vcc = ATM_SD(sock);
487 if (test_bit(ATM_VF_RELEASED,&vcc->flags) || 482 if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
488 test_bit(ATM_VF_CLOSE,&vcc->flags) || 483 test_bit(ATM_VF_CLOSE, &vcc->flags) ||
489 !test_bit(ATM_VF_READY, &vcc->flags)) 484 !test_bit(ATM_VF_READY, &vcc->flags))
490 return 0; 485 return 0;
491 486
492 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &error); 487 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &error);
493 if (!skb) 488 if (!skb)
494 return error; 489 return error;
495 490
496 copied = skb->len; 491 copied = skb->len;
497 if (copied > size) { 492 if (copied > size) {
498 copied = size; 493 copied = size;
499 msg->msg_flags |= MSG_TRUNC; 494 msg->msg_flags |= MSG_TRUNC;
500 } 495 }
501 496
502 error = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 497 error = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
503 if (error) 498 if (error)
504 return error; 499 return error;
505 sock_recv_ts_and_drops(msg, sk, skb); 500 sock_recv_ts_and_drops(msg, sk, skb);
506 pr_debug("%d -= %d\n", atomic_read(&sk->sk_rmem_alloc), skb->truesize); 501 pr_debug("%d -= %d\n", atomic_read(&sk->sk_rmem_alloc), skb->truesize);
507 atm_return(vcc, skb->truesize); 502 atm_return(vcc, skb->truesize);
508 skb_free_datagram(sk, skb); 503 skb_free_datagram(sk, skb);
509 return copied; 504 return copied;
510 } 505 }
511 506
512
513 int vcc_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m, 507 int vcc_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
514 size_t total_len) 508 size_t total_len)
515 { 509 {
516 struct sock *sk = sock->sk; 510 struct sock *sk = sock->sk;
517 DEFINE_WAIT(wait); 511 DEFINE_WAIT(wait);
518 struct atm_vcc *vcc; 512 struct atm_vcc *vcc;
519 struct sk_buff *skb; 513 struct sk_buff *skb;
520 int eff,error; 514 int eff, error;
521 const void __user *buff; 515 const void __user *buff;
522 int size; 516 int size;
523 517
524 lock_sock(sk); 518 lock_sock(sk);
525 if (sock->state != SS_CONNECTED) { 519 if (sock->state != SS_CONNECTED) {
526 error = -ENOTCONN; 520 error = -ENOTCONN;
527 goto out; 521 goto out;
528 } 522 }
529 if (m->msg_name) { 523 if (m->msg_name) {
530 error = -EISCONN; 524 error = -EISCONN;
531 goto out; 525 goto out;
532 } 526 }
533 if (m->msg_iovlen != 1) { 527 if (m->msg_iovlen != 1) {
534 error = -ENOSYS; /* fix this later @@@ */ 528 error = -ENOSYS; /* fix this later @@@ */
535 goto out; 529 goto out;
536 } 530 }
537 buff = m->msg_iov->iov_base; 531 buff = m->msg_iov->iov_base;
538 size = m->msg_iov->iov_len; 532 size = m->msg_iov->iov_len;
539 vcc = ATM_SD(sock); 533 vcc = ATM_SD(sock);
540 if (test_bit(ATM_VF_RELEASED, &vcc->flags) || 534 if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
541 test_bit(ATM_VF_CLOSE, &vcc->flags) || 535 test_bit(ATM_VF_CLOSE, &vcc->flags) ||
542 !test_bit(ATM_VF_READY, &vcc->flags)) { 536 !test_bit(ATM_VF_READY, &vcc->flags)) {
543 error = -EPIPE; 537 error = -EPIPE;
544 send_sig(SIGPIPE, current, 0); 538 send_sig(SIGPIPE, current, 0);
545 goto out; 539 goto out;
546 } 540 }
547 if (!size) { 541 if (!size) {
548 error = 0; 542 error = 0;
549 goto out; 543 goto out;
550 } 544 }
551 if (size < 0 || size > vcc->qos.txtp.max_sdu) { 545 if (size < 0 || size > vcc->qos.txtp.max_sdu) {
552 error = -EMSGSIZE; 546 error = -EMSGSIZE;
553 goto out; 547 goto out;
554 } 548 }
555 549
556 eff = (size+3) & ~3; /* align to word boundary */ 550 eff = (size+3) & ~3; /* align to word boundary */
557 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 551 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
558 error = 0; 552 error = 0;
559 while (!(skb = alloc_tx(vcc,eff))) { 553 while (!(skb = alloc_tx(vcc, eff))) {
560 if (m->msg_flags & MSG_DONTWAIT) { 554 if (m->msg_flags & MSG_DONTWAIT) {
561 error = -EAGAIN; 555 error = -EAGAIN;
562 break; 556 break;
563 } 557 }
564 schedule(); 558 schedule();
565 if (signal_pending(current)) { 559 if (signal_pending(current)) {
566 error = -ERESTARTSYS; 560 error = -ERESTARTSYS;
567 break; 561 break;
568 } 562 }
569 if (test_bit(ATM_VF_RELEASED,&vcc->flags) || 563 if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
570 test_bit(ATM_VF_CLOSE,&vcc->flags) || 564 test_bit(ATM_VF_CLOSE, &vcc->flags) ||
571 !test_bit(ATM_VF_READY,&vcc->flags)) { 565 !test_bit(ATM_VF_READY, &vcc->flags)) {
572 error = -EPIPE; 566 error = -EPIPE;
573 send_sig(SIGPIPE, current, 0); 567 send_sig(SIGPIPE, current, 0);
574 break; 568 break;
575 } 569 }
576 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE); 570 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
577 } 571 }
578 finish_wait(sk->sk_sleep, &wait); 572 finish_wait(sk->sk_sleep, &wait);
579 if (error) 573 if (error)
580 goto out; 574 goto out;
581 skb->dev = NULL; /* for paths shared with net_device interfaces */ 575 skb->dev = NULL; /* for paths shared with net_device interfaces */
582 ATM_SKB(skb)->atm_options = vcc->atm_options; 576 ATM_SKB(skb)->atm_options = vcc->atm_options;
583 if (copy_from_user(skb_put(skb,size),buff,size)) { 577 if (copy_from_user(skb_put(skb, size), buff, size)) {
584 kfree_skb(skb); 578 kfree_skb(skb);
585 error = -EFAULT; 579 error = -EFAULT;
586 goto out; 580 goto out;
587 } 581 }
588 if (eff != size) memset(skb->data+size,0,eff-size); 582 if (eff != size)
589 error = vcc->dev->ops->send(vcc,skb); 583 memset(skb->data + size, 0, eff-size);
584 error = vcc->dev->ops->send(vcc, skb);
590 error = error ? error : size; 585 error = error ? error : size;
591 out: 586 out:
592 release_sock(sk); 587 release_sock(sk);
593 return error; 588 return error;
594 } 589 }
595 590
596
597 unsigned int vcc_poll(struct file *file, struct socket *sock, poll_table *wait) 591 unsigned int vcc_poll(struct file *file, struct socket *sock, poll_table *wait)
598 { 592 {
599 struct sock *sk = sock->sk; 593 struct sock *sk = sock->sk;
600 struct atm_vcc *vcc; 594 struct atm_vcc *vcc;
601 unsigned int mask; 595 unsigned int mask;
602 596
603 sock_poll_wait(file, sk->sk_sleep, wait); 597 sock_poll_wait(file, sk->sk_sleep, wait);
604 mask = 0; 598 mask = 0;
605 599
606 vcc = ATM_SD(sock); 600 vcc = ATM_SD(sock);
607 601
608 /* exceptional events */ 602 /* exceptional events */
609 if (sk->sk_err) 603 if (sk->sk_err)
610 mask = POLLERR; 604 mask = POLLERR;
611 605
612 if (test_bit(ATM_VF_RELEASED, &vcc->flags) || 606 if (test_bit(ATM_VF_RELEASED, &vcc->flags) ||
613 test_bit(ATM_VF_CLOSE, &vcc->flags)) 607 test_bit(ATM_VF_CLOSE, &vcc->flags))
614 mask |= POLLHUP; 608 mask |= POLLHUP;
615 609
616 /* readable? */ 610 /* readable? */
617 if (!skb_queue_empty(&sk->sk_receive_queue)) 611 if (!skb_queue_empty(&sk->sk_receive_queue))
618 mask |= POLLIN | POLLRDNORM; 612 mask |= POLLIN | POLLRDNORM;
619 613
620 /* writable? */ 614 /* writable? */
621 if (sock->state == SS_CONNECTING && 615 if (sock->state == SS_CONNECTING &&
622 test_bit(ATM_VF_WAITING, &vcc->flags)) 616 test_bit(ATM_VF_WAITING, &vcc->flags))
623 return mask; 617 return mask;
624 618
625 if (vcc->qos.txtp.traffic_class != ATM_NONE && 619 if (vcc->qos.txtp.traffic_class != ATM_NONE &&
626 vcc_writable(sk)) 620 vcc_writable(sk))
627 mask |= POLLOUT | POLLWRNORM | POLLWRBAND; 621 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
628 622
629 return mask; 623 return mask;
630 } 624 }
631 625
632 626 static int atm_change_qos(struct atm_vcc *vcc, struct atm_qos *qos)
633 static int atm_change_qos(struct atm_vcc *vcc,struct atm_qos *qos)
634 { 627 {
635 int error; 628 int error;
636 629
637 /* 630 /*
638 * Don't let the QoS change the already connected AAL type nor the 631 * Don't let the QoS change the already connected AAL type nor the
639 * traffic class. 632 * traffic class.
640 */ 633 */
641 if (qos->aal != vcc->qos.aal || 634 if (qos->aal != vcc->qos.aal ||
642 qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class || 635 qos->rxtp.traffic_class != vcc->qos.rxtp.traffic_class ||
643 qos->txtp.traffic_class != vcc->qos.txtp.traffic_class) 636 qos->txtp.traffic_class != vcc->qos.txtp.traffic_class)
644 return -EINVAL; 637 return -EINVAL;
645 error = adjust_tp(&qos->txtp,qos->aal); 638 error = adjust_tp(&qos->txtp, qos->aal);
646 if (!error) error = adjust_tp(&qos->rxtp,qos->aal); 639 if (!error)
647 if (error) return error; 640 error = adjust_tp(&qos->rxtp, qos->aal);
648 if (!vcc->dev->ops->change_qos) return -EOPNOTSUPP; 641 if (error)
642 return error;
643 if (!vcc->dev->ops->change_qos)
644 return -EOPNOTSUPP;
649 if (sk_atm(vcc)->sk_family == AF_ATMPVC) 645 if (sk_atm(vcc)->sk_family == AF_ATMPVC)
650 return vcc->dev->ops->change_qos(vcc,qos,ATM_MF_SET); 646 return vcc->dev->ops->change_qos(vcc, qos, ATM_MF_SET);
651 return svc_change_qos(vcc,qos); 647 return svc_change_qos(vcc, qos);
652 } 648 }
653 649
654
655 static int check_tp(const struct atm_trafprm *tp) 650 static int check_tp(const struct atm_trafprm *tp)
656 { 651 {
657 /* @@@ Should be merged with adjust_tp */ 652 /* @@@ Should be merged with adjust_tp */
658 if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS) return 0; 653 if (!tp->traffic_class || tp->traffic_class == ATM_ANYCLASS)
654 return 0;
659 if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr && 655 if (tp->traffic_class != ATM_UBR && !tp->min_pcr && !tp->pcr &&
660 !tp->max_pcr) return -EINVAL; 656 !tp->max_pcr)
661 if (tp->min_pcr == ATM_MAX_PCR) return -EINVAL; 657 return -EINVAL;
658 if (tp->min_pcr == ATM_MAX_PCR)
659 return -EINVAL;
662 if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR && 660 if (tp->min_pcr && tp->max_pcr && tp->max_pcr != ATM_MAX_PCR &&
663 tp->min_pcr > tp->max_pcr) return -EINVAL; 661 tp->min_pcr > tp->max_pcr)
662 return -EINVAL;
664 /* 663 /*
665 * We allow pcr to be outside [min_pcr,max_pcr], because later 664 * We allow pcr to be outside [min_pcr,max_pcr], because later
666 * adjustment may still push it in the valid range. 665 * adjustment may still push it in the valid range.
667 */ 666 */
668 return 0; 667 return 0;
669 } 668 }
670 669
671
672 static int check_qos(const struct atm_qos *qos) 670 static int check_qos(const struct atm_qos *qos)
673 { 671 {
674 int error; 672 int error;
675 673
676 if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class) 674 if (!qos->txtp.traffic_class && !qos->rxtp.traffic_class)
677 return -EINVAL; 675 return -EINVAL;
678 if (qos->txtp.traffic_class != qos->rxtp.traffic_class && 676 if (qos->txtp.traffic_class != qos->rxtp.traffic_class &&
679 qos->txtp.traffic_class && qos->rxtp.traffic_class && 677 qos->txtp.traffic_class && qos->rxtp.traffic_class &&
680 qos->txtp.traffic_class != ATM_ANYCLASS && 678 qos->txtp.traffic_class != ATM_ANYCLASS &&
681 qos->rxtp.traffic_class != ATM_ANYCLASS) return -EINVAL; 679 qos->rxtp.traffic_class != ATM_ANYCLASS)
680 return -EINVAL;
682 error = check_tp(&qos->txtp); 681 error = check_tp(&qos->txtp);
683 if (error) return error; 682 if (error)
683 return error;
684 return check_tp(&qos->rxtp); 684 return check_tp(&qos->rxtp);
685 } 685 }
686 686
687 int vcc_setsockopt(struct socket *sock, int level, int optname, 687 int vcc_setsockopt(struct socket *sock, int level, int optname,
688 char __user *optval, unsigned int optlen) 688 char __user *optval, unsigned int optlen)
689 { 689 {
690 struct atm_vcc *vcc; 690 struct atm_vcc *vcc;
691 unsigned long value; 691 unsigned long value;
692 int error; 692 int error;
693 693
694 if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname)) 694 if (__SO_LEVEL_MATCH(optname, level) && optlen != __SO_SIZE(optname))
695 return -EINVAL; 695 return -EINVAL;
696 696
697 vcc = ATM_SD(sock); 697 vcc = ATM_SD(sock);
698 switch (optname) { 698 switch (optname) {
699 case SO_ATMQOS: 699 case SO_ATMQOS:
700 { 700 {
701 struct atm_qos qos; 701 struct atm_qos qos;
702 702
703 if (copy_from_user(&qos,optval,sizeof(qos))) 703 if (copy_from_user(&qos, optval, sizeof(qos)))
704 return -EFAULT; 704 return -EFAULT;
705 error = check_qos(&qos); 705 error = check_qos(&qos);
706 if (error) return error; 706 if (error)
707 if (sock->state == SS_CONNECTED) 707 return error;
708 return atm_change_qos(vcc,&qos); 708 if (sock->state == SS_CONNECTED)
709 if (sock->state != SS_UNCONNECTED) 709 return atm_change_qos(vcc, &qos);
710 return -EBADFD; 710 if (sock->state != SS_UNCONNECTED)
711 vcc->qos = qos; 711 return -EBADFD;
712 set_bit(ATM_VF_HASQOS,&vcc->flags); 712 vcc->qos = qos;
713 return 0; 713 set_bit(ATM_VF_HASQOS, &vcc->flags);
714 } 714 return 0;
715 case SO_SETCLP:
716 if (get_user(value,(unsigned long __user *)optval))
717 return -EFAULT;
718 if (value) vcc->atm_options |= ATM_ATMOPT_CLP;
719 else vcc->atm_options &= ~ATM_ATMOPT_CLP;
720 return 0;
721 default:
722 if (level == SOL_SOCKET) return -EINVAL;
723 break;
724 } 715 }
725 if (!vcc->dev || !vcc->dev->ops->setsockopt) return -EINVAL; 716 case SO_SETCLP:
726 return vcc->dev->ops->setsockopt(vcc,level,optname,optval,optlen); 717 if (get_user(value, (unsigned long __user *)optval))
718 return -EFAULT;
719 if (value)
720 vcc->atm_options |= ATM_ATMOPT_CLP;
721 else
722 vcc->atm_options &= ~ATM_ATMOPT_CLP;
723 return 0;
724 default:
725 if (level == SOL_SOCKET)
726 return -EINVAL;
727 break;
728 }
729 if (!vcc->dev || !vcc->dev->ops->setsockopt)
730 return -EINVAL;
731 return vcc->dev->ops->setsockopt(vcc, level, optname, optval, optlen);
727 } 732 }
728 733
729
730 int vcc_getsockopt(struct socket *sock, int level, int optname, 734 int vcc_getsockopt(struct socket *sock, int level, int optname,
731 char __user *optval, int __user *optlen) 735 char __user *optval, int __user *optlen)
732 { 736 {
733 struct atm_vcc *vcc; 737 struct atm_vcc *vcc;
734 int len; 738 int len;
735 739
736 if (get_user(len, optlen)) 740 if (get_user(len, optlen))
737 return -EFAULT; 741 return -EFAULT;
738 if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname)) 742 if (__SO_LEVEL_MATCH(optname, level) && len != __SO_SIZE(optname))
739 return -EINVAL; 743 return -EINVAL;
740 744
741 vcc = ATM_SD(sock); 745 vcc = ATM_SD(sock);
742 switch (optname) { 746 switch (optname) {
743 case SO_ATMQOS: 747 case SO_ATMQOS:
744 if (!test_bit(ATM_VF_HASQOS,&vcc->flags)) 748 if (!test_bit(ATM_VF_HASQOS, &vcc->flags))
745 return -EINVAL; 749 return -EINVAL;
746 return copy_to_user(optval,&vcc->qos,sizeof(vcc->qos)) ? 750 return copy_to_user(optval, &vcc->qos, sizeof(vcc->qos))
747 -EFAULT : 0; 751 ? -EFAULT : 0;
748 case SO_SETCLP: 752 case SO_SETCLP:
749 return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 : 753 return put_user(vcc->atm_options & ATM_ATMOPT_CLP ? 1 : 0,
750 0,(unsigned long __user *)optval) ? -EFAULT : 0; 754 (unsigned long __user *)optval) ? -EFAULT : 0;
751 case SO_ATMPVC: 755 case SO_ATMPVC:
752 { 756 {
753 struct sockaddr_atmpvc pvc; 757 struct sockaddr_atmpvc pvc;
754 758
755 if (!vcc->dev || 759 if (!vcc->dev || !test_bit(ATM_VF_ADDR, &vcc->flags))
756 !test_bit(ATM_VF_ADDR,&vcc->flags)) 760 return -ENOTCONN;
757 return -ENOTCONN; 761 pvc.sap_family = AF_ATMPVC;
758 pvc.sap_family = AF_ATMPVC; 762 pvc.sap_addr.itf = vcc->dev->number;
759 pvc.sap_addr.itf = vcc->dev->number; 763 pvc.sap_addr.vpi = vcc->vpi;
760 pvc.sap_addr.vpi = vcc->vpi; 764 pvc.sap_addr.vci = vcc->vci;
761 pvc.sap_addr.vci = vcc->vci; 765 return copy_to_user(optval, &pvc, sizeof(pvc)) ? -EFAULT : 0;
762 return copy_to_user(optval,&pvc,sizeof(pvc)) ? 766 }
763 -EFAULT : 0; 767 default:
764 } 768 if (level == SOL_SOCKET)
765 default: 769 return -EINVAL;
766 if (level == SOL_SOCKET) return -EINVAL;
767 break; 770 break;
768 } 771 }
769 if (!vcc->dev || !vcc->dev->ops->getsockopt) return -EINVAL; 772 if (!vcc->dev || !vcc->dev->ops->getsockopt)
773 return -EINVAL;
770 return vcc->dev->ops->getsockopt(vcc, level, optname, optval, len); 774 return vcc->dev->ops->getsockopt(vcc, level, optname, optval, len);
771 } 775 }
772 776
773 static int __init atm_init(void) 777 static int __init atm_init(void)
774 { 778 {
775 int error; 779 int error;
776 780
777 if ((error = proto_register(&vcc_proto, 0)) < 0) 781 error = proto_register(&vcc_proto, 0);
782 if (error < 0)
778 goto out; 783 goto out;
779 784 error = atmpvc_init();
780 if ((error = atmpvc_init()) < 0) { 785 if (error < 0) {
781 pr_err("atmpvc_init() failed with %d\n", error); 786 pr_err("atmpvc_init() failed with %d\n", error);
782 goto out_unregister_vcc_proto; 787 goto out_unregister_vcc_proto;
783 } 788 }
784 if ((error = atmsvc_init()) < 0) { 789 error = atmsvc_init();
790 if (error < 0) {
785 pr_err("atmsvc_init() failed with %d\n", error); 791 pr_err("atmsvc_init() failed with %d\n", error);
786 goto out_atmpvc_exit; 792 goto out_atmpvc_exit;
787 } 793 }
788 if ((error = atm_proc_init()) < 0) { 794 error = atm_proc_init();