arch/sparc64/solaris/timod.c

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