void cleanup_module(void) { rtos_irq_disable(&irq_handle); rtos_irq_free(&irq_handle); while (close_rt(sock) == -EAGAIN) { set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout(1*HZ); /* wait a second */ } while (close_rt(tdma) == -EAGAIN) { set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout(1*HZ); /* wait a second */ } rtos_event_sem_delete(&event_sem); rtos_task_delete(&task); }
void cleanup_module(void) { /* Important: First close the socket! */ while (close_rt(sock) == -EAGAIN) { rtos_print("rt_server: Not all buffers freed yet - waiting...\n"); set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout(1*HZ); /* wait a second */ } rtos_task_delete(&rt_task); }
void cleanup_module(void) { if (start_timer) stop_rt_timer(); while (close_rt(sock) == -EAGAIN) { set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(1*HZ); /* wait a second */ } /* rt_task_delete */ rt_task_delete(&rt_task); /* destroy the fifo */ rtf_destroy(PRINT); printk("packets sent:\t\t%10lu\npackets received:\t%10lu\npacketloss:\t\t" "%10lu%%\n", sent, rcvd, 100-((100*rcvd)/sent)); }
void cleanup_module(void) { rt_shutdown_irq(parirq); rt_free_global_irq(parirq); outb(0, PAR_CONTROL); /* Important: First close the socket! */ while (close_rt(sock) == -EAGAIN) { printk("rt_server: Socket busy - waiting...\n"); set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(1*HZ); /* wait a second */ } rt_sem_delete(&tx_sem); rt_task_delete(&xmit_task); rt_task_delete(&recv_task); rtf_destroy(PRINT_FIFO); }
int init_module(void) { unsigned int add_rtskbs = 30; int ret; unsigned long local_ip; unsigned long client_ip; if (strlen(local_ip_s) != 0) local_ip = rt_inet_aton(local_ip_s); else local_ip = INADDR_ANY; client_ip = rt_inet_aton(client_ip_s); if (reply_size < sizeof(nanosecs_t)) reply_size = sizeof(nanosecs_t); rtos_print("local ip address %s(%8x):%d\n", local_ip_s, (unsigned int)local_ip, RCV_PORT); rtos_print("client ip address %s(%8x):%d\n", client_ip_s, (unsigned int)client_ip, XMT_PORT); rtos_print("reply message size=%d\n", reply_size); /* create rt-socket */ rtos_print("create rtsocket\n"); if ((sock = socket_rt(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { rtos_print("socket not created\n"); return sock; } /* bind the rt-socket to local_addr */ rtos_print("bind rtsocket to local address:port\n"); memset(&local_addr, 0, sizeof(struct sockaddr_in)); local_addr.sin_family = AF_INET; local_addr.sin_port = htons(RCV_PORT); local_addr.sin_addr.s_addr = local_ip; if ((ret = bind_rt(sock, (struct sockaddr *)&local_addr, sizeof(struct sockaddr_in))) < 0) { close_rt(sock); rtos_print("can't bind rtsocket\n"); return ret; } /* set client-addr */ rtos_print("connect rtsocket to client address:port\n"); memset(&client_addr, 0, sizeof(struct sockaddr_in)); client_addr.sin_family = AF_INET; client_addr.sin_port = htons(XMT_PORT); client_addr.sin_addr.s_addr = client_ip; if ((ret = connect_rt(sock, (struct sockaddr *)&client_addr, sizeof(struct sockaddr_in))) < 0) { close_rt(sock); rtos_print("can't connect rtsocket\n"); return ret; } /* extend the socket pool */ ret = ioctl_rt(sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs); if (ret != (int)add_rtskbs) { close_rt(sock); rtos_print("ioctl_rt(RTNET_RTIOC_EXTPOOL) = %d\n", ret); return -1; } ret = rtos_task_init(&rt_task, (void *)process, 0, 10); return ret; }
int init_module(void) { unsigned int add_rtskbs = 30; int ret; unsigned long local_ip; unsigned long server_ip; if (strlen(local_ip_s) != 0) local_ip = rt_inet_aton(local_ip_s); else local_ip = INADDR_ANY; server_ip = rt_inet_aton(server_ip_s); rtf_create(PRINT_FIFO, 40000); rt_sem_init(&tx_sem, 0); rt_printk("local ip address %s=%8x\n", local_ip_s, (unsigned int) local_ip); rt_printk("server ip address %s=%8x\n", server_ip_s, (unsigned int) server_ip); /* create rt-socket */ rt_printk("create rtsocket\n"); if ((sock = socket_rt(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { rt_printk("socket not created\n"); return sock; } /* extend the socket pool */ ret = ioctl_rt(sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs); if (ret != (int)add_rtskbs) { close_rt(sock); rt_printk("ioctl_rt(RTNET_RTIOC_EXTPOOL) = %d\n", ret); return -1; } /* bind the rt-socket to local_addr */ local_addr.sin_family = AF_INET; local_addr.sin_port = htons(RCV_PORT); local_addr.sin_addr.s_addr = local_ip; if ((ret = bind_rt(sock, (struct sockaddr *)&local_addr, sizeof(struct sockaddr_in))) < 0) { close_rt(sock); rt_printk("can't bind rtsocket\n"); return ret; } /* set server-addr */ server_addr.sin_family = AF_INET; server_addr.sin_port = htons(SRV_PORT); server_addr.sin_addr.s_addr = server_ip; rt_task_init(&xmit_task,(void *)process,0,4096,10,0,NULL); rt_task_resume(&xmit_task); rt_task_init(&recv_task,(void *)echo_rcv,0,4096,9,0,NULL); rt_task_resume(&recv_task); rt_request_global_irq(parirq, parport_irq_handler); rt_startup_irq(parirq); outb(0xFF, PAR_DATA); outb(0x14 + KHZ0_1, PAR_CONTROL); return ret; }
int main(int argc, char *argv[]) { int ret; unsigned int i; struct sockaddr_in local_addr; struct in_addr dest_ip; while (1) { switch (getopt(argc, argv, "d:s:t")) { case 'd': dest_ip_s = optarg; break; case 's': size = atoi(optarg); break; case 't': start_timer = 1; break; case -1: goto end_of_opt; default: printf("usage: %s -d <dest_ip> -s <size> -t\n", argv[0]); return 0; } } end_of_opt: inet_aton(dest_ip_s, &dest_ip); if (size > 65505) size = 65505; signal(SIGTERM, catch_signal); signal(SIGINT, catch_signal); mlockall(MCL_CURRENT|MCL_FUTURE); printf("destination ip address %s=%08x\n", dest_ip_s, dest_ip.s_addr); printf("size %d\n", size); printf("start timer %d\n", start_timer); /* fill output buffer with test pattern */ for (i = 0; i < sizeof(buffer_out); i++) buffer_out[i] = i & 0xFF; /* create rt-socket */ sock = socket_rt(AF_INET,SOCK_DGRAM,0); if (sock < 0) { printf(" socket_rt() = %d!\n", sock); return sock; } /* extend the socket pool */ ret = ioctl_rt(sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs); if (ret != (int)add_rtskbs) { printf(" ioctl_rt(RT_IOC_SO_EXTPOOL) = %d\n", ret); close_rt(sock); return -1; } /* bind the rt-socket to a port */ memset(&local_addr, 0, sizeof(struct sockaddr_in)); local_addr.sin_family = AF_INET; local_addr.sin_port = htons(PORT); local_addr.sin_addr.s_addr = INADDR_ANY; ret = bind_rt(sock, (struct sockaddr *)&local_addr, sizeof(struct sockaddr_in)); if (ret < 0) { printf(" bind_rt() = %d!\n", ret); close_rt(sock); return ret; } /* set destination address */ memset(&dest_addr, 0, sizeof(struct sockaddr_in)); dest_addr.sin_family = AF_INET; dest_addr.sin_port = htons(PORT); dest_addr.sin_addr = dest_ip; if (start_timer) { rt_timer_start(TM_ONESHOT); } ret = rt_task_create(&rt_recv_task, "Receiver", 0, 10, 0); if (ret != 0) { printf(" rt_task_create(recv) = %d!\n", ret); close_rt(sock); return ret; } ret = rt_task_create(&rt_xmit_task, "Sender", 0, 9, 0); if (ret != 0) { printf(" rt_task_create(xmit) = %d!\n", ret); close_rt(sock); rt_task_delete(&rt_recv_task); return ret; } rt_task_start(&rt_recv_task, recv_msg, NULL); rt_task_start(&rt_xmit_task, xmit_msg, NULL); pause(); if (start_timer) rt_timer_stop(); /* Important: First close the socket! */ while (close_rt(sock) == -EAGAIN) { printf("frag-ip: Socket busy - waiting...\n"); sleep(1); } rt_task_delete(&rt_xmit_task); rt_task_delete(&rt_recv_task); return 0; }
int main(int argc, char *argv[]) { int sockfd = 0; int ret = 0; RT_TASK *lxrtnettsk; char msg[] = "This message was sent using rtnet_lxrt."; /* Set address structures to zero. */ memset(&local_addr, 0, sizeof(struct sockaddr_in)); memset(&server_addr, 0, sizeof(struct sockaddr_in)); printf("RTnet, simpleclient for NEWLXRT\n"); /* Check arguments and set addresses. */ if (argc == 4) { local_addr.sin_family = AF_INET; local_addr.sin_addr.s_addr = INADDR_ANY; local_addr.sin_port = htons(atoi(argv[1])); server_addr.sin_family = AF_INET; inet_aton(argv[2], &server_addr.sin_addr); server_addr.sin_port = htons(atoi(argv[3])); } else { fprintf(stderr, "Usage: " "%s <local-port> " "<server-ip> <server-port>\n", argv[0]); exit(1); } /* Lock allocated memory into RAM. */ mlockall(MCL_CURRENT|MCL_FUTURE); /* Create new socket. */ sockfd = socket_rt(AF_INET, SOCK_DGRAM, 0); if (sockfd < 0) { printf("Error opening socket: %d\n", sockfd); exit(1); } /* Initialize a real time buddy. */ lxrtnettsk = rt_task_init(4800, 1, 0, 0); if (NULL == lxrtnettsk) { close_rt(sockfd); printf("CANNOT INIT MASTER TASK\n"); exit(1); } /* Switch over to hard realtime mode. */ rt_make_hard_real_time(); /* Bind socket to local address specified as parameter. */ ret = bind_rt(sockfd, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in)); /* Specify destination address for socket; needed for rt_socket_send(). */ connect_rt(sockfd, (struct sockaddr *) &server_addr, sizeof(struct sockaddr_in)); /* Send a message. */ send_rt(sockfd, msg, sizeof(msg), 0); /* Switch over to soft realtime mode. */ rt_make_soft_real_time(); /* Close socket. * Note: call must be in soft-mode because socket was created as non-rt! */ close_rt(sockfd); /* Delete realtime buddy. */ rt_task_delete(lxrtnettsk); return 0; }