开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
timod.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：23k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

timod.c：源码内容
  1. /* $Id: timod.c,v 1.16.2.1 2001/12/18 22:15:25 davem Exp $
  2.  * timod.c: timod emulation.
  3.  *
  4.  * Copyright (C) 1998 Patrik Rak (prak3264@ss1000.ms.mff.cuni.cz)
  5.  *
  6.  * Streams & timod emulation based on code
  7.  * Copyright (C) 1995, 1996 Mike Jagdis (jaggy@purplet.demon.co.uk)
  8.  *
  9.  */
  10.  
  11. #include <linux/types.h>
  12. #include <linux/kernel.h>
  13. #include <linux/sched.h>
  14. #include <linux/smp.h>
  15. #include <linux/smp_lock.h>
  16. #include <linux/ioctl.h>
  17. #include <linux/fs.h>
  18. #include <linux/file.h>
  19. #include <linux/netdevice.h>
  20. #include <linux/poll.h>
  22. #include <net/sock.h>
  24. #include <asm/uaccess.h>
  25. #include <asm/termios.h>
  27. #include "conv.h"
  28. #include "socksys.h"
  30. extern asmlinkage int sys_ioctl(unsigned int fd, unsigned int cmd, 
  31. unsigned long arg);
  32. extern asmlinkage int sys32_ioctl(unsigned int fd, unsigned int cmd,
  33. u32 arg);
  34. asmlinkage int solaris_ioctl(unsigned int fd, unsigned int cmd, u32 arg);
  36. static spinlock_t timod_pagelock = SPIN_LOCK_UNLOCKED;
  37. static char * page = NULL ;
  39. #ifndef DEBUG_SOLARIS_KMALLOC
  41. #define mykmalloc kmalloc
  42. #define mykfree kfree
  44. #else
  46. void * mykmalloc(size_t s, int gfp)
  47. {
  48. static char * page;
  49. static size_t free = 0;
  50. void * r;
  51. s = ((s + 63) & ~63);
  52. if( s > PAGE_SIZE ) {
  53. SOLD("too big size, calling real kmalloc");
  54. return kmalloc(s, gfp);
  55. }
  56. if( s > free ) {
  57. /* we are wasting memory, but we don't care */
  58. page = (char *)__get_free_page(gfp);
  59. free = PAGE_SIZE;
  60. }
  61. r = page;
  62. page += s;
  63. free -= s;
  64. return r;
  65. }
  67. void mykfree(void *p)
  68. {
  69. }
  71. #endif
  73. #ifndef DEBUG_SOLARIS
  75. #define BUF_SIZE PAGE_SIZE
  76. #define PUT_MAGIC(a,m)
  77. #define SCHECK_MAGIC(a,m)
  78. #define BUF_OFFSET 0
  79. #define MKCTL_TRAILER 0
  81. #else
  83. #define BUF_SIZE (PAGE_SIZE-2*sizeof(u64))
  84. #define BUFPAGE_MAGIC 0xBADC0DEDDEADBABEL
  85. #define MKCTL_MAGIC 0xDEADBABEBADC0DEDL
  86. #define PUT_MAGIC(a,m) do{(*(u64*)(a))=(m);}while(0)
  87. #define SCHECK_MAGIC(a,m) do{if((*(u64*)(a))!=(m))printk("%s,%u,%s(): magic %08x at %p corrupted!n",
  88. __FILE__,__LINE__,__FUNCTION__,(m),(a));}while(0)
  89. #define BUF_OFFSET sizeof(u64)
  90. #define MKCTL_TRAILER sizeof(u64)
  92. #endif
  94. static char *getpage( void )
  95. {
  96. char *r;
  97. SOLD("getting page");
  98. spin_lock(&timod_pagelock);
  99. if (page) {
  100. r = page;
  101. page = NULL;
  102. spin_unlock(&timod_pagelock);
  103. SOLD("got cached");
  104. return r + BUF_OFFSET;
  105. }
  106. spin_unlock(&timod_pagelock);
  107. SOLD("getting new");
  108. r = (char *)__get_free_page(GFP_KERNEL);
  109. PUT_MAGIC(r,BUFPAGE_MAGIC);
  110. PUT_MAGIC(r+PAGE_SIZE-sizeof(u64),BUFPAGE_MAGIC);
  111. return r + BUF_OFFSET;
  112. }
  114. static void putpage(char *p)
  115. {
  116. SOLD("putting page");
  117. p = p - BUF_OFFSET;
  118. SCHECK_MAGIC(p,BUFPAGE_MAGIC);
  119. SCHECK_MAGIC(p+PAGE_SIZE-sizeof(u64),BUFPAGE_MAGIC);
  120. spin_lock(&timod_pagelock);
  121. if (page) {
  122. spin_unlock(&timod_pagelock);
  123. free_page((unsigned long)p);
  124. SOLD("freed it");
  125. } else {
  126. page = p;
  127. spin_unlock(&timod_pagelock);
  128. SOLD("cached it");
  129. }
  130. }
  132. static struct T_primsg *timod_mkctl(int size)
  133. {
  134. struct T_primsg *it;
  136. SOLD("creating primsg");
  137. it = (struct T_primsg *)mykmalloc(size+sizeof(*it)-sizeof(s32)+2*MKCTL_TRAILER, GFP_KERNEL);
  138. if (it) {
  139. SOLD("got it");
  140. it->pri = MSG_HIPRI;
  141. it->length = size;
  142. PUT_MAGIC((char*)((u64)(((char *)&it->type)+size+7)&~7),MKCTL_MAGIC);
  143. }
  144. return it;
  145. }
  147. static void timod_wake_socket(unsigned int fd)
  148. {
  149. struct socket *sock;
  151. SOLD("wakeing socket");
  152. sock = &current->files->fd[fd]->f_dentry->d_inode->u.socket_i;
  153. wake_up_interruptible(&sock->wait);
  154. read_lock(&sock->sk->callback_lock);
  155. if (sock->fasync_list && !test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
  156. __kill_fasync(sock->fasync_list, SIGIO, POLL_IN);
  157. read_unlock(&sock->sk->callback_lock);
  158. SOLD("done");
  159. }
  161. static void timod_queue(unsigned int fd, struct T_primsg *it)
  162. {
  163. struct sol_socket_struct *sock;
  165. SOLD("queuing primsg");
  166. sock = (struct sol_socket_struct *)current->files->fd[fd]->private_data;
  167. it->next = sock->pfirst;
  168. sock->pfirst = it;
  169. if (!sock->plast)
  170. sock->plast = it;
  171. timod_wake_socket(fd);
  172. SOLD("done");
  173. }
  175. static void timod_queue_end(unsigned int fd, struct T_primsg *it)
  176. {
  177. struct sol_socket_struct *sock;
  179. SOLD("queuing primsg at end");
  180. sock = (struct sol_socket_struct *)current->files->fd[fd]->private_data;
  181. it->next = NULL;
  182. if (sock->plast)
  183. sock->plast->next = it;
  184. else
  185. sock->pfirst = it;
  186. sock->plast = it;
  187. SOLD("done");
  188. }
  190. static void timod_error(unsigned int fd, int prim, int terr, int uerr)
  191. {
  192. struct T_primsg *it;
  194. SOLD("making error");
  195. it = timod_mkctl(sizeof(struct T_error_ack));
  196. if (it) {
  197. struct T_error_ack *err = (struct T_error_ack *)&it->type;
  199. SOLD("got it");
  200. err->PRIM_type = T_ERROR_ACK;
  201. err->ERROR_prim = prim;
  202. err->TLI_error = terr;
  203. err->UNIX_error = uerr; /* FIXME: convert this */
  204. timod_queue(fd, it);
  205. }
  206. SOLD("done");
  207. }
  209. static void timod_ok(unsigned int fd, int prim)
  210. {
  211. struct T_primsg *it;
  212. struct T_ok_ack *ok;
  214. SOLD("creating ok ack");
  215. it = timod_mkctl(sizeof(*ok));
  216. if (it) {
  217. SOLD("got it");
  218. ok = (struct T_ok_ack *)&it->type;
  219. ok->PRIM_type = T_OK_ACK;
  220. ok->CORRECT_prim = prim;
  221. timod_queue(fd, it);
  222. }
  223. SOLD("done");
  224. }
  226. static int timod_optmgmt(unsigned int fd, int flag, char *opt_buf, int opt_len, int do_ret)
  227. {
  228. int error, failed;
  229. int ret_space, ret_len;
  230. long args[5];
  231. char *ret_pos,*ret_buf;
  232. int (*sys_socketcall)(int, unsigned long *) =
  233. (int (*)(int, unsigned long *))SYS(socketcall);
  234. mm_segment_t old_fs = get_fs();
  236. SOLD("entry");
  237. SOLDD(("fd %u flg %u buf %p len %u doret %u",fd,flag,opt_buf,opt_len,do_ret));
  238. if (!do_ret && (!opt_buf || opt_len <= 0))
  239. return 0;
  240. SOLD("getting page");
  241. ret_pos = ret_buf = getpage();
  242. ret_space = BUF_SIZE;
  243. ret_len = 0;
  245. error = failed = 0;
  246. SOLD("looping");
  247. while(opt_len >= sizeof(struct opthdr)) {
  248. struct opthdr *opt;
  249. int orig_opt_len; 
  250. SOLD("loop start");
  251. opt = (struct opthdr *)ret_pos; 
  252. if (ret_space < sizeof(struct opthdr)) {
  253. failed = TSYSERR;
  254. break;
  255. }
  256. SOLD("getting opthdr");
  257. if (copy_from_user(opt, opt_buf, sizeof(struct opthdr)) ||
  258. opt->len > opt_len) {
  259. failed = TBADOPT;
  260. break;
  261. }
  262. SOLD("got opthdr");
  263. if (flag == T_NEGOTIATE) {
  264. char *buf;
  266. SOLD("handling T_NEGOTIATE");
  267. buf = ret_pos + sizeof(struct opthdr);
  268. if (ret_space < opt->len + sizeof(struct opthdr) ||
  269. copy_from_user(buf, opt_buf+sizeof(struct opthdr), opt->len)) {
  270. failed = TSYSERR;
  271. break;
  272. }
  273. SOLD("got optdata");
  274. args[0] = fd;
  275. args[1] = opt->level;
  276. args[2] = opt->name;
  277. args[3] = (long)buf;
  278. args[4] = opt->len;
  279. SOLD("calling SETSOCKOPT");
  280. set_fs(KERNEL_DS);
  281. error = sys_socketcall(SYS_SETSOCKOPT, args);
  282. set_fs(old_fs);
  283. if (error) {
  284. failed = TBADOPT;
  285. break;
  286. }
  287. SOLD("SETSOCKOPT ok");
  288. }
  289. orig_opt_len = opt->len;
  290. opt->len = ret_space - sizeof(struct opthdr);
  291. if (opt->len < 0) {
  292. failed = TSYSERR;
  293. break;
  294. }
  295. args[0] = fd;
  296. args[1] = opt->level;
  297. args[2] = opt->name;
  298. args[3] = (long)(ret_pos+sizeof(struct opthdr));
  299. args[4] = (long)&opt->len;
  300. SOLD("calling GETSOCKOPT");
  301. set_fs(KERNEL_DS);
  302. error = sys_socketcall(SYS_GETSOCKOPT, args);
  303. set_fs(old_fs);;
  304. if (error) {
  305. failed = TBADOPT;
  306. break;
  307. }
  308. SOLD("GETSOCKOPT ok");
  309. ret_space -= sizeof(struct opthdr) + opt->len;
  310. ret_len += sizeof(struct opthdr) + opt->len;
  311. ret_pos += sizeof(struct opthdr) + opt->len;
  312. opt_len -= sizeof(struct opthdr) + orig_opt_len;
  313. opt_buf += sizeof(struct opthdr) + orig_opt_len;
  314. SOLD("loop end");
  315. }
  316. SOLD("loop done");
  317. if (do_ret) {
  318. SOLD("generating ret msg");
  319. if (failed)
  320. timod_error(fd, T_OPTMGMT_REQ, failed, -error);
  321. else {
  322. struct T_primsg *it;
  323. it = timod_mkctl(sizeof(struct T_optmgmt_ack) + ret_len);
  324. if (it) {
  325. struct T_optmgmt_ack *ack =
  326. (struct T_optmgmt_ack *)&it->type;
  327. SOLD("got primsg");
  328. ack->PRIM_type = T_OPTMGMT_ACK;
  329. ack->OPT_length = ret_len;
  330. ack->OPT_offset = sizeof(struct T_optmgmt_ack);
  331. ack->MGMT_flags = (failed ? T_FAILURE : flag);
  332. memcpy(((char*)ack)+sizeof(struct T_optmgmt_ack),
  333. ret_buf, ret_len);
  334. timod_queue(fd, it);
  335. }
  336. }
  337. }
  338. SOLDD(("put_page %pn", ret_buf));
  339. putpage(ret_buf);
  340. SOLD("done");
  341. return 0;
  342. }
  344. int timod_putmsg(unsigned int fd, char *ctl_buf, int ctl_len,
  345. char *data_buf, int data_len, int flags)
  346. {
  347. int ret, error, terror;
  348. char *buf;
  349. struct file *filp;
  350. struct inode *ino;
  351. struct sol_socket_struct *sock;
  352. mm_segment_t old_fs = get_fs();
  353. long args[6];
  354. int (*sys_socketcall)(int, unsigned long *) =
  355. (int (*)(int, unsigned long *))SYS(socketcall);
  356. int (*sys_sendto)(int, void *, size_t, unsigned, struct sockaddr *, int) =
  357. (int (*)(int, void *, size_t, unsigned, struct sockaddr *, int))SYS(sendto);
  358. filp = current->files->fd[fd];
  359. ino = filp->f_dentry->d_inode;
  360. sock = (struct sol_socket_struct *)filp->private_data;
  361. SOLD("entry");
  362. if (get_user(ret, (int *)A(ctl_buf)))
  363. return -EFAULT;
  364. switch (ret) {
  365. case T_BIND_REQ:
  366. {
  367. struct T_bind_req req;
  369. SOLDD(("bind %016lx(%016lx)n", sock, filp));
  370. SOLD("T_BIND_REQ");
  371. if (sock->state != TS_UNBND) {
  372. timod_error(fd, T_BIND_REQ, TOUTSTATE, 0);
  373. return 0;
  374. }
  375. SOLD("state ok");
  376. if (copy_from_user(&req, ctl_buf, sizeof(req))) {
  377. timod_error(fd, T_BIND_REQ, TSYSERR, EFAULT);
  378. return 0;
  379. }
  380. SOLD("got ctl req");
  381. if (req.ADDR_offset && req.ADDR_length) {
  382. if (req.ADDR_length > BUF_SIZE) {
  383. timod_error(fd, T_BIND_REQ, TSYSERR, EFAULT);
  384. return 0;
  385. }
  386. SOLD("req size ok");
  387. buf = getpage();
  388. if (copy_from_user(buf, ctl_buf + req.ADDR_offset, req.ADDR_length)) {
  389. timod_error(fd, T_BIND_REQ, TSYSERR, EFAULT);
  390. putpage(buf);
  391. return 0;
  392. }
  393. SOLD("got ctl data");
  394. args[0] = fd;
  395. args[1] = (long)buf;
  396. args[2] = req.ADDR_length;
  397. SOLD("calling BIND");
  398. set_fs(KERNEL_DS);
  399. error = sys_socketcall(SYS_BIND, args);
  400. set_fs(old_fs);
  401. putpage(buf);
  402. SOLD("BIND returned");
  403. } else 
  404. error = 0;
  405. if (!error) {
  406. struct T_primsg *it;
  407. if (req.CONIND_number) {
  408.    args[0] = fd;
  409.    args[1] = req.CONIND_number;
  410.    SOLD("calling LISTEN");
  411.    set_fs(KERNEL_DS);
  412.    error = sys_socketcall(SYS_LISTEN, args);
  413.    set_fs(old_fs);
  414.    SOLD("LISTEN done");
  415.    }
  416. it = timod_mkctl(sizeof(struct T_bind_ack)+sizeof(struct sockaddr));
  417. if (it) {
  418. struct T_bind_ack *ack;
  420. ack = (struct T_bind_ack *)&it->type;
  421. ack->PRIM_type = T_BIND_ACK;
  422. ack->ADDR_offset = sizeof(*ack);
  423. ack->ADDR_length = sizeof(struct sockaddr);
  424. ack->CONIND_number = req.CONIND_number;
  425. args[0] = fd;
  426. args[1] = (long)(ack+sizeof(*ack));
  427. args[2] = (long)&ack->ADDR_length;
  428. set_fs(KERNEL_DS);
  429. sys_socketcall(SYS_GETSOCKNAME,args);
  430. set_fs(old_fs);
  431. sock->state = TS_IDLE;
  432. timod_ok(fd, T_BIND_REQ);
  433. timod_queue_end(fd, it);
  434. SOLD("BIND done");
  435. return 0;
  436. }
  437. }
  438. SOLD("some error");
  439. switch (error) {
  440. case -EINVAL:
  441. terror = TOUTSTATE;
  442. error = 0;
  443. break;
  444. case -EACCES:
  445. terror = TACCES;
  446. error = 0;
  447. break;
  448. case -EADDRNOTAVAIL:
  449. case -EADDRINUSE:
  450. terror = TNOADDR;
  451. error = 0;
  452. break;
  453. default:
  454. terror = TSYSERR;
  455. break;
  456. }
  457. timod_error(fd, T_BIND_REQ, terror, -error);
  458. SOLD("BIND done");
  459. return 0;
  460. }
  461. case T_CONN_REQ:
  462. {
  463. struct T_conn_req req;
  464. unsigned short oldflags;
  465. struct T_primsg *it;
  466. SOLD("T_CONN_REQ");
  467. if (sock->state != TS_UNBND && sock->state != TS_IDLE) {
  468. timod_error(fd, T_CONN_REQ, TOUTSTATE, 0);
  469. return 0;
  470. }
  471. SOLD("state ok");
  472. if (copy_from_user(&req, ctl_buf, sizeof(req))) {
  473. timod_error(fd, T_CONN_REQ, TSYSERR, EFAULT);
  474. return 0;
  475. }
  476. SOLD("got ctl req");
  477. if (ctl_len > BUF_SIZE) {
  478. timod_error(fd, T_CONN_REQ, TSYSERR, EFAULT);
  479. return 0;
  480. }
  481. SOLD("req size ok");
  482. buf = getpage();
  483. if (copy_from_user(buf, ctl_buf, ctl_len)) {
  484. timod_error(fd, T_CONN_REQ, TSYSERR, EFAULT);
  485. putpage(buf);
  486. return 0;
  487. }
  488. #ifdef DEBUG_SOLARIS
  489. {
  490. char * ptr = buf;
  491. int len = ctl_len;
  492. printk("returned data (%d bytes): ",len);
  493. while( len-- ) {
  494. if (!(len & 7))
  495. printk(" ");
  496. printk("%02x",(unsigned char)*ptr++);
  497. }
  498. printk("n");
  499. }
  500. #endif
  501. SOLD("got ctl data");
  502. args[0] = fd;
  503. args[1] = (long)buf+req.DEST_offset;
  504. args[2] = req.DEST_length;
  505. oldflags = filp->f_flags;
  506. filp->f_flags &= ~O_NONBLOCK;
  507. SOLD("calling CONNECT");
  508. set_fs(KERNEL_DS);
  509. error = sys_socketcall(SYS_CONNECT, args);
  510. set_fs(old_fs);
  511. filp->f_flags = oldflags;
  512. SOLD("CONNECT done");
  513. if (!error) {
  514. struct T_conn_con *con;
  515. SOLD("no error");
  516. it = timod_mkctl(ctl_len);
  517. if (!it) {
  518. putpage(buf);
  519. return -ENOMEM;
  520. }
  521. con = (struct T_conn_con *)&it->type;
  522. #ifdef DEBUG_SOLARIS
  523. {
  524. char * ptr = buf;
  525. int len = ctl_len;
  526. printk("returned data (%d bytes): ",len);
  527. while( len-- ) {
  528. if (!(len & 7))
  529. printk(" ");
  530. printk("%02x",(unsigned char)*ptr++);
  531. }
  532. printk("n");
  533. }
  534. #endif
  535. memcpy(con, buf, ctl_len);
  536. SOLD("copied ctl_buf");
  537. con->PRIM_type = T_CONN_CON;
  538. sock->state = TS_DATA_XFER;
  539. } else {
  540. struct T_discon_ind *dis;
  541. SOLD("some error");
  542. it = timod_mkctl(sizeof(*dis));
  543. if (!it) {
  544. putpage(buf);
  545. return -ENOMEM;
  546. }
  547. SOLD("got primsg");
  548. dis = (struct T_discon_ind *)&it->type;
  549. dis->PRIM_type = T_DISCON_IND;
  550. dis->DISCON_reason = -error; /* FIXME: convert this as in iABI_errors() */
  551. dis->SEQ_number = 0;
  552. }
  553. putpage(buf);
  554. timod_ok(fd, T_CONN_REQ);
  555. it->pri = 0;
  556. timod_queue_end(fd, it);
  557. SOLD("CONNECT done");
  558. return 0;
  559. }
  560. case T_OPTMGMT_REQ:
  561. {
  562. struct T_optmgmt_req req;
  563. SOLD("OPTMGMT_REQ");
  564. if (copy_from_user(&req, ctl_buf, sizeof(req)))
  565. return -EFAULT;
  566. SOLD("got req");
  567. return timod_optmgmt(fd, req.MGMT_flags,
  568. req.OPT_offset > 0 ? ctl_buf + req.OPT_offset : NULL,
  569. req.OPT_length, 1);
  570. }
  571. case T_UNITDATA_REQ:
  572. {
  573. struct T_unitdata_req req;
  575. int err;
  576. SOLD("T_UNITDATA_REQ");
  577. if (sock->state != TS_IDLE && sock->state != TS_DATA_XFER) {
  578. timod_error(fd, T_CONN_REQ, TOUTSTATE, 0);
  579. return 0;
  580. }
  581. SOLD("state ok");
  582. if (copy_from_user(&req, ctl_buf, sizeof(req))) {
  583. timod_error(fd, T_CONN_REQ, TSYSERR, EFAULT);
  584. return 0;
  585. }
  586. SOLD("got ctl req");
  587. #ifdef DEBUG_SOLARIS
  588. {
  589. char * ptr = ctl_buf+req.DEST_offset;
  590. int len = req.DEST_length;
  591. printk("socket address (%d bytes): ",len);
  592. while( len-- ) {
  593. char c;
  594. if (get_user(c,ptr))
  595. printk("??");
  596. else
  597. printk("%02x",(unsigned char)c);
  598. ptr++;
  599. }
  600. printk("n");
  601. }
  602. #endif
  603. err = sys_sendto(fd, data_buf, data_len, 0, req.DEST_length > 0 ? (struct sockaddr*)(ctl_buf+req.DEST_offset) : NULL, req.DEST_length);
  604. if (err == data_len)
  605. return 0;
  606. if(err >= 0) {
  607. printk("timod: sendto failed to send all the datan");
  608. return 0;
  609. }
  610. timod_error(fd, T_CONN_REQ, TSYSERR, -err);
  611. return 0;
  612. }
  613. default:
  614. printk(KERN_INFO "timod_putmsg: unsupported command %u.n", ret);
  615. break;
  616. }
  617. return -EINVAL;
  618. }
  620. int timod_getmsg(unsigned int fd, char *ctl_buf, int ctl_maxlen, s32 *ctl_len,
  621. char *data_buf, int data_maxlen, s32 *data_len, int *flags_p)
  622. {
  623. int error;
  624. int oldflags;
  625. struct file *filp;
  626. struct inode *ino;
  627. struct sol_socket_struct *sock;
  628. struct T_unitdata_ind udi;
  629. mm_segment_t old_fs = get_fs();
  630. long args[6];
  631. char *tmpbuf;
  632. int tmplen;
  633. int (*sys_socketcall)(int, unsigned long *) =
  634. (int (*)(int, unsigned long *))SYS(socketcall);
  635. int (*sys_recvfrom)(int, void *, size_t, unsigned, struct sockaddr *, int *);
  637. SOLD("entry");
  638. SOLDD(("%u %p %d %p %p %d %p %dn", fd, ctl_buf, ctl_maxlen, ctl_len, data_buf, data_maxlen, data_len, *flags_p));
  639. filp = current->files->fd[fd];
  640. ino = filp->f_dentry->d_inode;
  641. sock = (struct sol_socket_struct *)filp->private_data;
  642. SOLDD(("%p %pn", sock->pfirst, sock->pfirst ? sock->pfirst->next : NULL));
  643. if ( ctl_maxlen > 0 && !sock->pfirst && ino->u.socket_i.type == SOCK_STREAM
  644. && sock->state == TS_IDLE) {
  645. SOLD("calling LISTEN");
  646. args[0] = fd;
  647. args[1] = -1;
  648. set_fs(KERNEL_DS);
  649. sys_socketcall(SYS_LISTEN, args);
  650. set_fs(old_fs);
  651. SOLD("LISTEN done");
  652. }
  653. if (!(filp->f_flags & O_NONBLOCK)) {
  654. poll_table wait_table, *wait;
  656. poll_initwait(&wait_table);
  657. wait = &wait_table;
  658. for(;;) {
  659. SOLD("loop");
  660. set_current_state(TASK_INTERRUPTIBLE);
  661. /* ! ( l<0 || ( l>=0 && ( ! pfirst || (flags == HIPRI && pri != HIPRI) ) ) ) */ 
  662. /* ( ! l<0 && ! ( l>=0 && ( ! pfirst || (flags == HIPRI && pri != HIPRI) ) ) ) */ 
  663. /* ( l>=0 && ( ! l>=0 || ! ( ! pfirst || (flags == HIPRI && pri != HIPRI) ) ) ) */ 
  664. /* ( l>=0 && ( l<0 || ( pfirst && ! (flags == HIPRI && pri != HIPRI) ) ) ) */ 
  665. /* ( l>=0 && ( l<0 || ( pfirst && (flags != HIPRI || pri == HIPRI) ) ) ) */ 
  666. /* ( l>=0 && ( pfirst && (flags != HIPRI || pri == HIPRI) ) ) */ 
  667. if (ctl_maxlen >= 0 && sock->pfirst && (*flags_p != MSG_HIPRI || sock->pfirst->pri == MSG_HIPRI))
  668. break;
  669. SOLD("cond 1 passed");
  670. if (
  671. #if 1
  672. *flags_p != MSG_HIPRI &&
  673. #endif
  674. ((filp->f_op->poll(filp, wait) & POLLIN) ||
  675. (filp->f_op->poll(filp, NULL) & POLLIN) ||
  676. signal_pending(current))
  677. ) {
  678. break;
  679. }
  680. if( *flags_p == MSG_HIPRI ) {
  681. SOLD("avoiding lockup");
  682. break ;
  683. }
  684. if(wait_table.error) {
  685. SOLD("wait-table error");
  686. poll_freewait(&wait_table);
  687. return wait_table.error;
  688. }
  689. SOLD("scheduling");
  690. schedule();
  691. }
  692. SOLD("loop done");
  693. current->state = TASK_RUNNING;
  694. poll_freewait(&wait_table);
  695. if (signal_pending(current)) {
  696. SOLD("signal pending");
  697. return -EINTR;
  698. }
  699. }
  700. if (ctl_maxlen >= 0 && sock->pfirst) {
  701. struct T_primsg *it = sock->pfirst;
  702. int l = min_t(int, ctl_maxlen, it->length);
  703. SCHECK_MAGIC((char*)((u64)(((char *)&it->type)+sock->offset+it->length+7)&~7),MKCTL_MAGIC);
  704. SOLD("purting ctl data");
  705. if(copy_to_user(ctl_buf,
  706. (char*)&it->type + sock->offset, l))
  707. return -EFAULT;
  708. SOLD("pur it");
  709. if(put_user(l, ctl_len))
  710. return -EFAULT;
  711. SOLD("set ctl_len");
  712. *flags_p = it->pri;
  713. it->length -= l;
  714. if (it->length) {
  715. SOLD("more ctl");
  716. sock->offset += l;
  717. return MORECTL;
  718. } else {
  719. SOLD("removing message");
  720. sock->pfirst = it->next;
  721. if (!sock->pfirst)
  722. sock->plast = NULL;
  723. SOLDD(("getmsg kfree %016lx->%016lxn", it, sock->pfirst));
  724. mykfree(it);
  725. sock->offset = 0;
  726. SOLD("ctl done");
  727. return 0;
  728. }
  729. }
  730. *flags_p = 0;
  731. if (ctl_maxlen >= 0) {
  732. SOLD("ACCEPT perhaps?");
  733. if (ino->u.socket_i.type == SOCK_STREAM && sock->state == TS_IDLE) {
  734. struct T_conn_ind ind;
  735. char *buf = getpage();
  736. int len = BUF_SIZE;
  738. SOLD("trying ACCEPT");
  739. if (put_user(ctl_maxlen - sizeof(ind), ctl_len))
  740. return -EFAULT;
  741. args[0] = fd;
  742. args[1] = (long)buf;
  743. args[2] = (long)&len;
  744. oldflags = filp->f_flags;
  745. filp->f_flags |= O_NONBLOCK;
  746. SOLD("calling ACCEPT");
  747. set_fs(KERNEL_DS);
  748. error = sys_socketcall(SYS_ACCEPT, args);
  749. set_fs(old_fs);
  750. filp->f_flags = oldflags;
  751. if (error < 0) {
  752. SOLD("some error");
  753. putpage(buf);
  754. return error;
  755. }
  756. if (error) {
  757. SOLD("connect");
  758. putpage(buf);
  759. if (sizeof(ind) > ctl_maxlen) {
  760. SOLD("generating CONN_IND");
  761. ind.PRIM_type = T_CONN_IND;
  762. ind.SRC_length = len;
  763. ind.SRC_offset = sizeof(ind);
  764. ind.OPT_length = ind.OPT_offset = 0;
  765. ind.SEQ_number = error;
  766. if(copy_to_user(ctl_buf, &ind, sizeof(ind))||
  767.    put_user(sizeof(ind)+ind.SRC_length,ctl_len))
  768. return -EFAULT;
  769. SOLD("CONN_IND created");
  770. }
  771. if (data_maxlen >= 0)
  772. put_user(0, data_len);
  773. SOLD("CONN_IND done");
  774. return 0;
  775. }
  776. if (len>ctl_maxlen) {
  777. SOLD("data don't fit");
  778. putpage(buf);
  779. return -EFAULT; /* XXX - is this ok ? */
  780. }
  781. if(copy_to_user(ctl_buf,buf,len) || put_user(len,ctl_len)){
  782. SOLD("can't copy data");
  783. putpage(buf);
  784. return -EFAULT;
  785. }
  786. SOLD("ACCEPT done");
  787. putpage(buf);
  788. }
  789. }
  790. SOLD("checking data req");
  791. if (data_maxlen <= 0) {
  792. if (data_maxlen == 0)
  793. put_user(0, data_len);
  794. if (ctl_maxlen >= 0)
  795. put_user(0, ctl_len);
  796. return -EAGAIN;
  797. }
  798. SOLD("wants data");
  799. if (ctl_maxlen > sizeof(udi) && sock->state == TS_IDLE) {
  800. SOLD("udi fits");
  801. tmpbuf = ctl_buf + sizeof(udi);
  802. tmplen = ctl_maxlen - sizeof(udi);
  803. } else {
  804. SOLD("udi does not fit");
  805. tmpbuf = NULL;
  806. tmplen = 0;
  807. }
  808. if (put_user(tmplen, ctl_len))
  809. return -EFAULT;
  810. SOLD("set ctl_len");
  811. oldflags = filp->f_flags;
  812. filp->f_flags |= O_NONBLOCK;
  813. SOLD("calling recvfrom");
  814. sys_recvfrom = (int (*)(int, void *, size_t, unsigned, struct sockaddr *, int *))SYS(recvfrom);
  815. error = sys_recvfrom(fd, data_buf, data_maxlen, 0, (struct sockaddr*)tmpbuf, ctl_len);
  816. filp->f_flags = oldflags;
  817. if (error < 0)
  818. return error;
  819. SOLD("error >= 0" ) ;
  820. if (error && ctl_maxlen > sizeof(udi) && sock->state == TS_IDLE) {
  821. SOLD("generating udi");
  822. udi.PRIM_type = T_UNITDATA_IND;
  823. get_user(udi.SRC_length, ctl_len);
  824. udi.SRC_offset = sizeof(udi);
  825. udi.OPT_length = udi.OPT_offset = 0;
  826. copy_to_user(ctl_buf, &udi, sizeof(udi));
  827. put_user(sizeof(udi)+udi.SRC_length, ctl_len);
  828. SOLD("udi done");
  829. } else
  830. put_user(0, ctl_len);
  831. put_user(error, data_len);
  832. SOLD("done");
  833. return 0;
  834. }
  836. asmlinkage int solaris_getmsg(unsigned int fd, u32 arg1, u32 arg2, u32 arg3)
  837. {
  838. struct file *filp;
  839. struct inode *ino;
  840. struct strbuf *ctlptr, *datptr;
  841. struct strbuf ctl, dat;
  842. int *flgptr;
  843. int flags;
  844. int error = -EBADF;
  846. SOLD("entry");
  847. lock_kernel();
  848. if(fd >= NR_OPEN) goto out;
  850. filp = current->files->fd[fd];
  851. if(!filp) goto out;
  853. ino = filp->f_dentry->d_inode;
  854. if (!ino) goto out;
  856. if (!ino->i_sock)
  857. goto out;
  859. ctlptr = (struct strbuf *)A(arg1);
  860. datptr = (struct strbuf *)A(arg2);
  861. flgptr = (int *)A(arg3);
  863. error = -EFAULT;
  865. if (ctlptr) {
  866. if (copy_from_user(&ctl,ctlptr,sizeof(struct strbuf)) || 
  867.     put_user(-1,&ctlptr->len))
  868. goto out;
  869. } else
  870. ctl.maxlen = -1;
  872. if (datptr) {
  873. if (copy_from_user(&dat,datptr,sizeof(struct strbuf)) || 
  874.     put_user(-1,&datptr->len))
  875. goto out;
  876. } else
  877. dat.maxlen = -1;
  879. if (get_user(flags,flgptr))
  880. goto out;
  882. switch (flags) {
  883. case 0:
  884. case MSG_HIPRI:
  885. case MSG_ANY:
  886. case MSG_BAND:
  887. break;
  888. default:
  889. error = -EINVAL;
  890. goto out;
  891. }
  893. error = timod_getmsg(fd,(char*)A(ctl.buf),ctl.maxlen,&ctlptr->len,
  894. (char*)A(dat.buf),dat.maxlen,&datptr->len,&flags);
  896. if (!error && put_user(flags,flgptr))
  897. error = -EFAULT;
  898. out:
  899. unlock_kernel();
  900. SOLD("done");
  901. return error;
  902. }
  904. asmlinkage int solaris_putmsg(unsigned int fd, u32 arg1, u32 arg2, u32 arg3)
  905. {
  906. struct file *filp;
  907. struct inode *ino;
  908. struct strbuf *ctlptr, *datptr;
  909. struct strbuf ctl, dat;
  910. int flags = (int) arg3;
  911. int error = -EBADF;
  913. SOLD("entry");
  914. lock_kernel();
  915. if(fd >= NR_OPEN) goto out;
  917. filp = current->files->fd[fd];
  918. if(!filp) goto out;
  920. ino = filp->f_dentry->d_inode;
  921. if (!ino) goto out;
  923. if (!ino->i_sock &&
  924. (MAJOR(ino->i_rdev) != 30 || MINOR(ino->i_rdev) != 1))
  925. goto out;
  927. ctlptr = (struct strbuf *)A(arg1);
  928. datptr = (struct strbuf *)A(arg2);
  930. error = -EFAULT;
  932. if (ctlptr) {
  933. if (copy_from_user(&ctl,ctlptr,sizeof(ctl)))
  934. goto out;
  935. if (ctl.len < 0 && flags) {
  936. error = -EINVAL;
  937. goto out;
  938. }
  939. } else {
  940. ctl.len = 0;
  941. ctl.buf = 0;
  942. }
  944. if (datptr) {
  945. if (copy_from_user(&dat,datptr,sizeof(dat)))
  946. goto out;
  947. } else {
  948. dat.len = 0;
  949. dat.buf = 0;
  950. }
  952. error = timod_putmsg(fd,(char*)A(ctl.buf),ctl.len,
  953. (char*)A(dat.buf),dat.len,flags);
  954. out:
  955. unlock_kernel();
  956. SOLD("done");
  957. return error;
  958. }