static void __exit kmem_exit(void)
{
PR_INFO("start");
kmem_cache_free(cache_p, p);
kmem_cache_destroy(cache_p);
PR_INFO("end");
}
/*
* The release implementation.
*/
static int kern_release(struct inode *inode, struct file *filp)
{
PR_INFO("start");
ssleep(2);
PR_INFO("end");
return 0;
}
static int nfct_parse(ginkgo_msg *msg)
{
struct nlmsghdr *nlh = NL_HEADER(msg);
nfct_msg *ctmsg = NFCT_MSG(msg);
__u16 nlm_type = nlh->nlmsg_type;
__u16 type = NFNL_MSG_TYPE(nlh->nlmsg_type);
__u16 subsys = NFNL_SUBSYS_ID(nlh->nlmsg_type);
if(nlm_type <= NLMSG_MIN_TYPE)
return -1;
ctmsg->subsys = subsys;
ctmsg->type = type;
ctmsg->entry = NULL;
if(ctmsg->subsys != NFNL_SUBSYS_CTNETLINK) {
PR_INFO("not supported subsys message type parsing:%d %d", subsys, type);
return 0;
}
switch(type) {
case IPCTNL_MSG_CT_NEW:
case IPCTNL_MSG_CT_DELETE:
return nfct_parse_ct(ctmsg, nlh);
default:
PR_INFO("unpexpected ct msg type:%d", type);
break;
}
return 0;
}
/* our own functions */
static void api_print_addressinfo(void *logical_adr)
{
struct page *page = virt_to_page(logical_adr);
if (page == NULL) {
PR_INFO("unable to translate address %p to page", logical_adr);
return;
}
PR_INFO(
"address %p, page:%p flags:0x%0*lx mapping:%p mapcount:%d count:%d\n",
logical_adr,
page, (int)(2 * sizeof(unsigned long)),
page->flags, page->mapping,
page_mapcount(page), page_count(page)
);
PR_INFO("PG_lru is %lu", page->flags & (1 << PG_lru));
PR_INFO("PG_private is %lu", page->flags & (1 << PG_private));
PR_INFO("PG_locked is %lu", page->flags & (1 << PG_locked));
/* Missing in newer kernels and so is remarked... */
/* PR_INFO("PG_buddy is %lu", page->flags & (1 << PG_buddy)); */
PR_INFO("PG_writeback is %lu", page->flags & (1 << PG_writeback));
PR_INFO("PG_slab is %lu", page->flags & (1 << PG_slab));
PR_INFO("PG_swapcache is %lu", page->flags & (1 << PG_swapcache));
PR_INFO("PG_active is %lu", page->flags & (1 << PG_active));
PR_INFO("PG_reserved is %lu", page->flags & (1 << PG_reserved));
}
/* our own functions */
static int __init kmem_init(void)
{
PR_INFO("start");
cache_p = kmem_cache_create(
/* name of cache (will appear in slabtop(1),
/proc/slabinfo and more. */
"veltzer",
/* size of objects in cache */
100,
/* alignment */
0,
/* flags (look at the docs, will you ?) */
SLAB_HWCACHE_ALIGN | SLAB_DEBUG_OBJECTS,
/* ctor/dtor to be called when each element is allocated
or deallocated */
NULL
);
if (IS_ERR(cache_p))
return PTR_ERR(cache_p);
p = kmem_cache_alloc(cache_p, GFP_KERNEL);
if (IS_ERR(p)) {
/* there is not too much that we can do here */
PR_ERROR("Cannot allocate memory");
kmem_cache_destroy(cache_p);
return PTR_ERR(p);
}
/* mempool_create(number,mempool_alloc_slab, mempool_free_slab,
drbd_request_cache); */
PR_INFO("end");
return 0;
}
static int
knamed_loop(void *data)
{
allow_signal(SIGHUP);
while (1) {
set_current_state(TASK_INTERRUPTIBLE);
if (kthread_should_stop()) {
break;
}
if (signal_pending(current)) {
flush_signals(current);
PR_INFO("SIGNAL received");
}
PR_INFO("Hello knamed_task");
schedule_timeout(5 * HZ);
}
knamed_task = NULL;
complete_and_exit(&comp, 0);
}
static void param_exit(void)
{
PR_INFO("start");
PR_INFO("myshort is a short integer: %hd", myshort);
PR_INFO("myint is an integer: %d", myint);
PR_INFO("mylong is a long integer: %ld", mylong);
PR_INFO("mystring is a string: %s", mystring);
}
// for uplink GTPU traffic on S-GW
//-----------------------------------------------------------------------------
static int _udp_thread(void *data)
//-----------------------------------------------------------------------------
{
int size, tx_size;
int bufsize = 8192;
#if defined(FLAG_GTPV1U_KERNEL_THREAD_SOCK_NO_WAIT)
int success_read = 0;
int failed_read = 0;
#endif
unsigned char buf[bufsize+1];
unsigned char gtp_resp[1024];
/* kernel thread initialization */
_gtpusp_sock.running = 1;
PR_INFO(MODULE_NAME": listening on port %d\n", gtpu_sgw_port);
/* main loop */
while(_gtpusp_sock.thread_stop_requested == 0){
if (kthread_should_stop()) {
_gtpusp_sock.running = 0;
PR_INFO(MODULE_NAME": kthread_stop initiated exit at %lu \n", jiffies);
return -1; //Exit from the thread. Return value will be passed to kthread_stop()
}
size = _gtpusp_ksocket_receive(_gtpusp_sock.sock, &_gtpusp_sock.addr, buf, bufsize);
if (size <= 0) {
if (size != -EAGAIN) {
pr_info(MODULE_NAME": error getting datagram, sock_recvmsg error = %d\n", size);
}
#if defined(FLAG_GTPV1U_KERNEL_THREAD_SOCK_NO_WAIT)
success_read = 0;
failed_read += 1;
if (failed_read > 10) failed_read = 10;
usleep_range(failed_read*20,failed_read*200);
#endif
} else {
#if defined(FLAG_GTPV1U_KERNEL_THREAD_SOCK_NO_WAIT)
success_read += 1;
failed_read = 0;
#endif
PR_INFO(MODULE_NAME": received %d bytes\n", size);
if ((tx_size = _gtpusp_ksocket_process_gtp(buf, size, gtp_resp)) > 0) {
//ksocket_send(_gtpusp_sock.sock, &_gtpusp_sock.addr_send, buf, gtp_resp, tx_size, NULL, 0));
}
}
}
_gtpusp_sock.running = 0;
if (kthread_should_stop()) {
PR_INFO(MODULE_NAME": kthread_stop initiated exit at %lu \n", jiffies);
return -1; //Exit from the thread. Return value will be passed to kthread_stop()
}
PR_INFO(MODULE_NAME": kthread do_exit()\n");
do_exit(0);
}
static void api_debug_address(unsigned int phys)
{
void *logical = __va(phys);
void *logical2 = phys_to_virt(phys);
unsigned int phys2 = __pa(logical);
PR_INFO("phys is %u", phys);
PR_INFO("logical is %p", logical);
PR_INFO("phys2 is %u", phys2);
PR_INFO("logical2 is %p", logical2);
api_print_addressinfo(logical);
}
//-----------------------------------------------------------------------------
static void
_gtpusp_tg4_add(struct sk_buff *old_skb_pP, const struct xt_action_param *par_pP)
{
//-----------------------------------------------------------------------------
struct iphdr *old_iph_p = ip_hdr(old_skb_pP);
struct gtpuhdr gtpuh;
uint16_t orig_iplen = 0;
// CONNMARK
enum ip_conntrack_info ctinfo;
struct nf_conn *ct = NULL;
u_int32_t newmark;
if (skb_linearize(old_skb_pP) < 0) {
PR_INFO(MODULE_NAME": skb no linearize\n");
return;
}
orig_iplen = ntohs(old_iph_p->tot_len);
//----------------------------------------------------------------------------
// CONNMARK
//----------------------------------------------------------------------------
ct = nf_ct_get(old_skb_pP, &ctinfo);
if (ct == NULL) {
PR_INFO(MODULE_NAME": _gtpusp_target_add force targinfo ltun %u to skb_pP mark %u\n",
((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->ltun,
old_skb_pP->mark);
newmark = ((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->ltun;
} else {
//XT_CONNMARK_RESTORE:
newmark = old_skb_pP->mark ^ ct->mark;
PR_INFO(MODULE_NAME": _gtpusp_target_add restore mark %u (skb mark %u ct mark %u) len %u sgw addr %x\n",
newmark, old_skb_pP->mark, ct->mark, orig_iplen,
((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->raddr);
if (newmark != ((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->ltun) {
pr_warn(MODULE_NAME": _gtpusp_target_add restore mark 0x%x mismatch ltun 0x%x (rtun 0x%x)",
newmark, ((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->ltun,
((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->rtun);
}
}
/* Add GTPu header */
gtpuh.flags = 0x30; /* v1 and Protocol-type=GTP */
gtpuh.msgtype = 0xff; /* T-PDU */
gtpuh.length = htons(orig_iplen);
gtpuh.tunid = htonl(((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->rtun);
_gtpusp_sock.addr_send.sin_addr.s_addr = ((const struct xt_gtpusp_target_info *)(par_pP->targinfo))->raddr;
_gtpusp_ksocket_send(_gtpusp_sock.sock, &_gtpusp_sock.addr_send, (unsigned char*)>puh, sizeof(gtpuh), (unsigned char*)old_iph_p, orig_iplen);
return ;
}
/*
* This is the poll implementation
*/
static unsigned int kern_poll(struct file *fp, poll_table *wait)
{
struct polldev *pd;
pd = (struct polldev *)fp->private_data;
PR_INFO("start %p", pd);
poll_wait(fp, &pd->wq, wait);
unsigned int mask = pd->state;
/* no need to reset the state
pd->state = 0;
*/
PR_INFO("return with %u", mask);
return mask;
}
static int __init mod_init(void)
{
PR_DEBUG("start");
api_debug_address(physaddr);
/*
* if (!request_mem_region(physaddr,size,)) {
* PR_ERROR("could not get the memory");
* return 1;
* }
*/
logical = ioremap(physaddr, size);
if (IS_ERR(logical)) {
pr_err("could not ioremap");
release_mem_region(physaddr, size);
return PTR_ERR(logical);
}
PR_INFO("got logical address %p", logical);
/* memset(logical,0,size);
*logical=5;
PR_INFO("read %c",*logical);
logical=phys_to_virt(physaddr);
for(i=0;i<170*1024*1024;i++)
logical[i]=0;
api_print_addressinfo((void*)(1024*1024*700));
api_print_addressinfo((void*)(1024*1024*695));
api_print_addressinfo((void*)(1024*1024*720));
*/
return 0;
}
static int param_init(void)
{
PR_INFO("start");
PR_INFO("myshort is a short integer: %hd", myshort);
PR_INFO("myint is an integer: %d", myint);
PR_INFO("mylong is a long integer: %ld", mylong);
PR_INFO("mystring is a string: %s", mystring);
PR_INFO("You may change some of the values now via /sys and see");
PR_INFO("the values changed");
PR_INFO("either by catting /sys or unloading the module and");
PR_INFO("looking at the unload printout...");
return 0;
}
//-----------------------------------------------------------------------------
static int
__init gtpusp_tg_init(void)
//-----------------------------------------------------------------------------
{
int err;
pr_info(MODULE_NAME": Initializing module (KVersion: %d)\n", KVERSION);
pr_info(MODULE_NAME": Copyright Polaris Networks 2010-2011\n");
pr_info(MODULE_NAME": Modified by EURECOM Lionel GAUTHIER 2014\n");
#ifndef CMAKER
pr_info(MODULE_NAME": Compiled %s at time %s\n",__DATE__,__TIME__);
#endif
#if defined(WITH_IPV6)
pr_info(MODULE_NAME": IPv4/IPv6 enabled\n");
#else
pr_info(MODULE_NAME": IPv4 only enabled\n");
#endif
pr_info(MODULE_NAME": params gtpu_enb_port=%u, gtpu_sgw_port=%u, sgw_addr=%s\n",
gtpu_enb_port, gtpu_sgw_port, sgw_addr);
// UDP socket socket
memset(&_gtpusp_sock, 0, sizeof(gtpusp_sock_t));
/* create a socket */
if ((err = sock_create(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &_gtpusp_sock.sock)) < 0 ) {
PR_INFO(": Could not create a datagram socket, error = %d\n", -ENXIO);
return err;
}
_gtpusp_sock.addr.sin_family = AF_INET;
_gtpusp_sock.addr.sin_port = htons(gtpu_sgw_port);
_gtpusp_sock.addr.sin_addr.s_addr = in_aton(sgw_addr);
_gtpusp_sock.addr_send.sin_family = AF_INET;
_gtpusp_sock.addr_send.sin_port = htons(gtpu_enb_port);
_gtpusp_sock.addr_send.sin_addr.s_addr = in_aton(sgw_addr);
_gtpusp_sock.thread_stop_requested = 0;
if ( (err = _gtpusp_sock.sock->ops->bind(_gtpusp_sock.sock, (struct sockaddr *)&_gtpusp_sock.addr, sizeof(struct sockaddr) ) ) < 0) {
pr_info(MODULE_NAME": Could not bind socket, error = %d\n", -err);
goto close_and_out;
}
// start kernel thread
_gtpusp_sock.thread = kthread_run((void *)_udp_thread, NULL, MODULE_NAME);
if (IS_ERR(_gtpusp_sock.thread)) {
pr_info(MODULE_NAME": unable to start kernel thread\n");
return -ENOMEM;
}
if((_gtpusp_sock.thread)) {
wake_up_process(_gtpusp_sock.thread);
}
return xt_register_targets(gtpusp_tg_reg, ARRAY_SIZE(gtpusp_tg_reg));
close_and_out:
sock_release(_gtpusp_sock.sock);
_gtpusp_sock.sock = NULL;
return err;
}
static int kern_release(struct inode *inode, struct file *filp)
{
struct polldev *pd;
PR_INFO("start");
pd = (struct polldev *)(filp->private_data);
kfree(pd);
return 0;
}
/*
* This is the open implementation
*/
static int kern_open(struct inode *inode, struct file *filp)
{
struct polldev *pd;
PR_INFO("start");
pd = kmalloc(sizeof(struct polldev), GFP_KERNEL);
if (IS_ERR(pd))
return PTR_ERR(pd);
init_waitqueue_head(&pd->wq);
pd->state = 0;
filp->private_data = pd;
return 0;
}
/*
* This is the ioctl implementation.
*/
static long kern_unlocked_ioctl(struct file *fp, unsigned int cmd,
unsigned long arg) {
struct polldev *pd;
pd = (struct polldev *)fp->private_data;
PR_INFO("start %p", pd);
switch (cmd) {
case IOCTL_EPOLL_WAKE:
PR_INFO("in WAKE");
pd->state = POLLIN;
wmb();
wake_up_all(&pd->wq);
return 0;
case IOCTL_EPOLL_RESET:
PR_INFO("in RESET");
pd->state = 0;
wmb();
wake_up_all(&pd->wq);
return 0;
}
return -ENOTTY;
}
static int
process_class_chaos(struct dns_query *query, uint8_t *buf)
{
uint8_t *p = buf;
struct dnshdr *resp;
if (query->qtype != TYPE_TXT && query->qtype != TYPE_ANY) {
PR_INFO("CHAOS type %d not implemented", query->qtype);
return answer_notimpl(query, buf);
}
if ((query->len == sizeof(id_server) - 1
&& memcmp(query->name, id_server, query->len) == 0)
|| (query->len == sizeof(hostname_bind) - 1
&& memcmp(query->name, hostname_bind, query->len) == 0))
{
memcpy(p, query->packet, sizeof(struct dnshdr) + query->qlen + 2 + 2);
p += sizeof(struct dnshdr) + query->qlen + 2 + 2;
p += fill_rr_str(p, sizeof(struct dnshdr), TYPE_TXT, CLASS_CHAOS,
sysctl_knamed_default_ttl, 8, "flygoast");
resp = (struct dnshdr *) buf;
RESP_SET(resp, 1, RCODE_NOERROR);
return p - buf;
}
if ((query->len == sizeof(version_server) - 1
&& memcmp(query->name, version_server, query->len) == 0)
|| (query->len == sizeof(version_bind) - 1
&& memcmp(query->name, version_bind, query->len) == 0))
{
if (sysctl_knamed_hide_version) {
return answer_refused(query, buf);
}
memcpy(p, query->packet, sizeof(struct dnshdr) + query->qlen + 2 + 2);
p += sizeof(struct dnshdr) + query->qlen + 2 + 2;
p += fill_rr_str(p, sizeof(struct dnshdr), TYPE_TXT, CLASS_CHAOS,
sysctl_knamed_default_ttl,
strlen(KNAMED_TOKEN),
KNAMED_TOKEN);
resp = (struct dnshdr *) buf;
RESP_SET(resp, 1, RCODE_NOERROR);
return p - buf;
}
return answer_notimpl(query, buf);
}
/*
* This is the ioctl implementation.
*/
static long kern_unlocked_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
/* the buffer which will be used for the transaction */
buffer b;
int err;
PR_DEBUG("start");
switch (cmd) {
case IOCTL_DIV_DOOPS:
/* get the data from the user */
err = copy_from_user(&b, (void *)arg, sizeof(b));
if (err) {
PR_ERROR("problem with copy_from_user");
return err;
}
PR_DEBUG("after copy");
PR_INFO("b.u1 is %llu", b.u1);
PR_INFO("b.u2 is %llu", b.u2);
PR_INFO("b.d1 is %lld", b.d1);
PR_INFO("b.d2 is %lld", b.d2);
b.udiv = b.u1 / b.u2;
b.umul = b.u1 * b.u2;
b.uadd = b.u1 + b.u2;
b.usub = b.u1 - b.u2;
b.ddiv = b.d1 / b.d2;
b.dmul = b.d1 * b.d2;
b.dadd = b.d1 + b.d2;
b.dsub = b.d1 - b.d2;
/* copy the data back to the user */
err = copy_to_user((void *)arg, &b, sizeof(b));
if (err) {
PR_ERROR("problem with copy_to_user");
return err;
}
/* everything is ok */
return 0;
}
return -EINVAL;
}
static int adu_lock(struct target *target)
{
uint64_t val;
CHECK_ERR(read_target(target, ALTD_CMD_REG, &val));
if (val & FBC_LOCKED)
PR_INFO("ADU already locked! Ignoring.\n");
val |= FBC_LOCKED;
CHECK_ERR(write_target(target, ALTD_CMD_REG, val));
return 0;
}
/*
* This is the ioctl implementation.
*/
static long kern_unlocked_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
PR_DEBUG("start");
switch (cmd) {
case IOCTL_RACE_EMPTY:
/* empty ioctl to 'just work'; */
/* PR_INFO("end"); */
return 0;
case IOCTL_RACE_SLEEP_SHORT:
/* long ioctl to stall for time */
msleep_interruptible(10000);
PR_INFO("end");
return 0;
case IOCTL_RACE_SLEEP_LONG:
/* long ioctl to stall for time */
/* ssleep(10000); */
msleep_interruptible(20000);
PR_INFO("end");
return 0;
}
PR_DEBUG("end");
return -EINVAL;
}
/* our own functions */
static int __init mod_init(void)
{
struct resource *rp;
PR_INFO("start");
rp = iomem_resource.child;
while (rp) {
pr_info("%0*llx-%0*llx\n",
8, (unsigned long long)rp->start,
8, (unsigned long long)rp->end
);
/* advance to the next resource... */
rp = rp->sibling;
}
return 0;
}
static int adu_unlock(struct target *target)
{
uint64_t val;
CHECK_ERR(read_target(target, ALTD_CMD_REG, &val));
if (!(val & FBC_LOCKED)) {
PR_INFO("ADU already unlocked!\n");
return 0;
}
val &= ~FBC_LOCKED;
CHECK_ERR(write_target(target, ALTD_CMD_REG, val));
return 0;
}
//-----------------------------------------------------------------------------
static int _gtpusp_ksocket_send(struct socket *sock_pP, struct sockaddr_in *addr_pP, unsigned char *gtpuh_pP, int len_gtpP, unsigned char *buf_ip_pP, int len_ipP)
//-----------------------------------------------------------------------------
{
struct msghdr msg;
struct iovec iov[2];
mm_segment_t oldfs;
int size = 0;
int err = 0;
int iov_index = 0;
if ( (err = sock_pP->ops->connect(sock_pP, (struct sockaddr *)addr_pP, sizeof(struct sockaddr), 0)) < 0 ) {
PR_INFO(MODULE_NAME": Could not connect to socket, error = %d\n", -err);
return 0;
}
if (sock_pP->sk == NULL) {
return 0;
}
if ((gtpuh_pP != NULL) && (len_gtpP > 0)) {
iov[iov_index].iov_base = gtpuh_pP;
iov[iov_index].iov_len = len_gtpP;
iov_index += 1;
}
if ((buf_ip_pP != NULL) && (len_ipP > 0)) {
iov[iov_index].iov_base = buf_ip_pP;
iov[iov_index].iov_len = len_ipP;
iov_index += 1;
}
msg.msg_flags = 0;
msg.msg_name = addr_pP;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = iov_index;
msg.msg_control = NULL;
oldfs = get_fs();
set_fs(KERNEL_DS);
size = sock_sendmsg(sock_pP,&msg,len_ipP+len_gtpP);
set_fs(oldfs);
return size;
}
static int __init knamed_init(void)
{
struct file *filp;
int ret;
int err;
PR_INFO("starting");
PR_INFO("Author: Gu Feng <*****@*****.**>");
PR_INFO("Version: %s", KNAMED_VERSION);
PR_INFO("Repository: https://github.com/flygoast/knamed.git");
filp = filp_open(KNAMED_CONF, O_RDONLY, 0);
if (IS_ERR(filp)) {
PR_INFO("conf file \"%s\" didn't existed, ignored", KNAMED_CONF);
goto init;
}
if (filp) {
fput(filp);
}
init:
ret = nf_register_hooks(knamed_ops, ARRAY_SIZE(knamed_ops));
if (ret < 0) {
PR_ERR("can't register hooks.");
goto cleanup;
}
knamed_memory_init();
knamed_procfs_init();
knamed_sysctl_register();
dns_init();
knamed_task = kthread_run(knamed_loop, NULL, "knamedtask");
if (IS_ERR(knamed_task)) {
PR_ERR("Create kernel thread failed");
err = PTR_ERR(knamed_task);
return err;
}
PR_INFO("started");
return 0;
cleanup:
return ret;
}
static void __exit knamed_exit(void)
{
nf_unregister_hooks(knamed_ops, ARRAY_SIZE(knamed_ops));
knamed_sysctl_unregister();
knamed_procfs_release();
dns_cleanup();
if (knamed_task) {
kthread_stop(knamed_task);
wait_for_completion(&comp);
}
knamed_memory_release();
PR_INFO("removed");
}
/* our own functions */
static int __init mod_init(void)
{
PR_INFO("start");
PR_INFO("name is %s", KBUILD_MODNAME);
PR_INFO("name is %s", THIS_MODULE->name);
PR_INFO("srcversion is %s", THIS_MODULE->srcversion);
PR_INFO("version is %s", THIS_MODULE->version);
/*
PR_INFO("init_size is %d", THIS_MODULE->init_size);
PR_INFO("core_size is %d", THIS_MODULE->core_size);
PR_INFO("init_text_size is %d", THIS_MODULE->init_text_size);
PR_INFO("core_text_size is %d", THIS_MODULE->core_text_size);
*/
PR_INFO("printk is %p", printk);
/* using this symbol_get function you can also get kernel symbols,
other modules symbols or your own exported symbols. */
PR_INFO("printk (via get) is %p", symbol_get("printk"));
return 0;
}
static int
knamed_port_sysctl(ctl_table *table, int write, void __user *buffer,
size_t *lenp, loff_t *ppos)
{
int *valp = table->data;
int val = *valp;
int rc;
rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (write && (*valp != val)) {
if ((*valp < 0) || (*valp > 65535)) {
PR_ERR("invalid port: %d, must be between 0-65535", *valp);
/* Restore the correct value */
*valp = val;
} else {
PR_INFO("change port from %d to %d", val, *valp);
}
}
return rc;
}
static int
knamed_default_ttl_sysctl(ctl_table *table, int write, void __user *buffer,
size_t *lenp, loff_t *ppos)
{
int *valp = table->data;
int val = *valp;
int rc;
rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (write && (*valp != val)) {
if (*valp < 0) {
PR_ERR("Invalid ttl: %d, must be positive", *valp);
/* Restore the correct value */
*valp = val;
} else {
PR_INFO("Change ttl from %d to %d", val, *valp);
}
}
return rc;
}
static void __exit mod_exit(void)
{
PR_INFO("start");
PR_INFO("end");
}
