src/afs/LINUX/osi_module.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * Linux module support routines.
  12  *
  13  */
  14 #include <afsconfig.h>
  15 #include "afs/param.h"
  16
  17 RCSID
  18     ("$Header$");
  19
  20 #include "afs/sysincludes.h"
  21 #include "afsincludes.h"
  22 #include "h/unistd.h"           /* For syscall numbers. */
  23 #include "h/mm.h"
  24
  25 #ifdef AFS_AMD64_LINUX20_ENV
  26 #include "../asm/ia32_unistd.h"
  27 #endif
  28
  29 #include <linux/module.h>
  30 #include <linux/proc_fs.h>
  31 #include <linux/slab.h>
  32 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
  33 #include <linux/init.h>
  34 #include <linux/sched.h>
  35 #endif
  36 #if !defined(EXPORTED_SYS_CALL_TABLE) && defined(HAVE_KERNEL_LINUX_SYSCALL_H)
  37 #include <linux/syscall.h>
  38 #endif
  39
  40 #ifdef AFS_SPARC64_LINUX24_ENV
  41 #define __NR_setgroups32      82        /* This number is not exported for some bizarre reason. */
  42 #endif
  43
  44 #if !defined(AFS_LINUX24_ENV)
  45 asmlinkage int (*sys_settimeofdayp) (struct timeval * tv,
  46                                      struct timezone * tz);
  47 #endif
  48 asmlinkage long (*sys_setgroupsp) (int gidsetsize, gid_t * grouplist);
  49 #ifdef EXPORTED_SYS_CALL_TABLE
  50 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_S390X_LINUX24_ENV)
  51 extern unsigned int sys_call_table[];   /* changed to uint because SPARC64 and S390X have syscalltable of 32bit items */
  52 #else
  53 extern void *sys_call_table[];  /* safer for other linuces */
  54 #endif
  55 #else /* EXPORTED_SYS_CALL_TABLE */
  56 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_S390X_LINUX24_ENV)
  57 static unsigned int *sys_call_table;    /* changed to uint because SPARC64 and S390X have syscalltable of 32bit items */
  58 #else
  59 static void **sys_call_table;   /* safer for other linuces */
  60 #endif
  61 #endif
  62
  63 #if defined(AFS_S390X_LINUX24_ENV)
  64 #define _S(x) ((x)<<1)
  65 #else
  66 #define _S(x) x
  67 #endif
  68
  69 extern struct file_system_type afs_fs_type;
  70
  71 static long get_page_offset(void);
  72
  73 #if defined(AFS_LINUX24_ENV)
  74 DECLARE_MUTEX(afs_global_lock);
  75 #else
  76 struct semaphore afs_global_lock = MUTEX;
  77 #endif
  78 int afs_global_owner = 0;
  79 #if !defined(AFS_LINUX24_ENV)
  80 unsigned long afs_linux_page_offset = 0;        /* contains the PAGE_OFFSET value */
  81 #endif
  82
  83 /* Since sys_ni_syscall is not exported, I need to cache it in order to restore
  84  * it.
  85  */
  86 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_S390X_LINUX24_ENV)
  87 static unsigned int afs_ni_syscall = 0;
  88 #else
  89 static void *afs_ni_syscall = 0;
  90 #endif
  91
  92 #ifdef AFS_AMD64_LINUX20_ENV
  93 #ifdef EXPORTED_IA32_SYS_CALL_TABLE
  94 extern void *ia32_sys_call_table[];
  95 #else
  96 static void **ia32_sys_call_table;
  97 #endif
  98
  99 static void *ia32_ni_syscall = 0;
 100 asmlinkage long (*sys32_setgroupsp) (int gidsetsize, u16 * grouplist);
 101 #if defined(__NR_ia32_setgroups32)
 102 asmlinkage long (*sys32_setgroups32p) (int gidsetsize, gid_t * grouplist);
 103 #endif /* __NR_ia32_setgroups32 */
 104 #endif /* AFS_AMD64_LINUX20_ENV */
 105
 106 #ifdef AFS_PPC64_LINUX20_ENV
 107 asmlinkage long (*sys32_setgroupsp)(int gidsetsize, gid_t *grouplist);
 108 #endif /* AFS_AMD64_LINUX20_ENV */
 109
 110 #ifdef AFS_SPARC64_LINUX20_ENV
 111 static unsigned int afs_ni_syscall32 = 0;
 112 asmlinkage int (*sys32_setgroupsp) (int gidsetsize,
 113                                     __kernel_gid_t32 * grouplist);
 114 #if defined(__NR_setgroups32)
 115 asmlinkage int (*sys32_setgroups32p) (int gidsetsize,
 116                                       __kernel_gid_t32 * grouplist);
 117 #endif /* __NR_setgroups32 */
 118 #ifdef EXPORTED_SYS_CALL_TABLE
 119 extern unsigned int sys_call_table32[];
 120 #else /* EXPORTED_SYS_CALL_TABLE */
 121 static unsigned int *sys_call_table32;
 122 #endif /* EXPORTED_SYS_CALL_TABLE */
 123
 124 asmlinkage int
 125 afs_syscall32(long syscall, long parm1, long parm2, long parm3, long parm4,
 126               long parm5)
 127 {
 128     __asm__ __volatile__("srl %o4, 0, %o4\n\t" "mov %o7, %i7\n\t"
 129                          "call afs_syscall\n\t" "srl %o5, 0, %o5\n\t"
 130                          "ret\n\t" "nop");
 131 }
 132 #endif /* AFS_SPARC64_LINUX20_ENV */
 133
 134 static int afs_ioctl(struct inode *, struct file *, unsigned int,
 135                      unsigned long);
 136
 137 static struct file_operations afs_syscall_fops = {
 138     .ioctl = afs_ioctl,
 139 };
 140
 141 int
 142 csdbproc_read(char *buffer, char **start, off_t offset, int count,
 143               int *eof, void *data)
 144 {
 145     int len, i, j;
 146     struct afs_q *cq, *tq;
 147     struct cell *tc;
 148     void *ret = NULL;
 149     char tbuffer[16];
 150     afs_uint32 addr;
 151
 152     len = 0;
 153     ObtainReadLock(&afs_xcell);
 154     for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
 155         tc = QTOC(cq); tq = QNext(cq);
 156         len += sprintf(buffer + len, ">%s #(%d/%d)\n", tc->cellName,
 157                        tc->cellNum, tc->cellIndex);
 158         for (j = 0; j < MAXCELLHOSTS; j++) {
 159             if (!tc->cellHosts[j]) break;
 160             addr = ntohl(tc->cellHosts[j]->addr->sa_ip);
 161             sprintf(tbuffer, "%d.%d.%d.%d",
 162                     (int)((addr>>24) & 0xff), (int)((addr>>16) & 0xff),
 163                     (int)((addr>>8)  & 0xff), (int)( addr      & 0xff));
 164             len += sprintf(buffer + len, "%s #%s\n", tbuffer, tbuffer);
 165         }
 166     }
 167     ReleaseReadLock(&afs_xcell);
 168
 169     if (offset >= len) {
 170         *start = buffer;
 171         *eof = 1;
 172         return 0;
 173     }
 174     *start = buffer + offset;
 175     if ((len -= offset) > count)
 176         return count;
 177     *eof = 1;
 178     return len;
 179 }
 180
 181 int
 182 peerproc_read(char *buffer, char **start, off_t offset, int count,
 183               int *eof, void *data)
 184 {
 185     int len, i, j;
 186     struct rx_peer *sep;
 187     void *ret = NULL;
 188     char tbuffer[16];
 189     afs_uint32 addr;
 190
 191     len = 0;
 192     for (i = 0, j = 0; i < 256; i++) {
 193         for (sep = rx_peerHashTable[i]; sep; sep = sep->next, j++) {
 194             len += sprintf(buffer + len, "%lx: next=0x%lx, host=0x%x, ", sep, sep->next,
 195                    sep->host);
 196             len += sprintf(buffer + len, "ifMTU=%d, natMTU=%d, maxMTU=%d\n", sep->ifMTU,
 197                    sep->natMTU, sep->maxMTU);
 198             len += sprintf(buffer + len, "\trtt=%d:%d, timeout(%d:%d), nSent=%d, reSends=%d\n",
 199                    sep->rtt, sep->rtt_dev, sep->timeout.sec,
 200                    sep->timeout.usec, sep->nSent, sep->reSends);
 201             len += sprintf(buffer + len, "\trefCount=%d, port=%d, idleWhen=0x%x\n",
 202                    sep->refCount, sep->port, sep->idleWhen);
 203             len += sprintf(buffer + len, "\tCongestionQueue (0x%x:0x%x), inPacketSkew=0x%x, outPacketSkew=0x%x\n",
 204                  sep->congestionQueue.prev, sep->congestionQueue.next,
 205                  sep->inPacketSkew, sep->outPacketSkew);
 206 #ifdef RX_ENABLE_LOCKS
 207             len += sprintf(buffer + len, "\tpeer_lock=%d\n", sep->peer_lock);
 208 #endif /* RX_ENABLE_LOCKS */
 209         }
 210     }
 211
 212     if (offset >= len) {
 213         *start = buffer;
 214         *eof = 1;
 215         return 0;
 216     }
 217     *start = buffer + offset;
 218     if ((len -= offset) > count)
 219         return count;
 220     *eof = 1;
 221     return len;
 222 }
 223
 224 int
 225 rxstatsproc_read(char *buffer, char **start, off_t offset, int count,
 226               int *eof, void *data)
 227 {
 228     int len, i, j;
 229     void *ret = NULL;
 230     char tbuffer[16];
 231     afs_uint32 addr;
 232
 233     len = 0;
 234     len += sprintf(buffer + len, "packetRequests = %d\n", rx_stats.packetRequests);
 235     len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_RECEIVE,
 236            rx_stats.receivePktAllocFailures);
 237     len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_SEND,
 238            rx_stats.sendPktAllocFailures);
 239     len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_SPECIAL,
 240            rx_stats.specialPktAllocFailures);
 241     len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_RECV_CBUF,
 242            rx_stats.receiveCbufPktAllocFailures);
 243     len += sprintf(buffer + len, "noPackets[%d] = %d\n", RX_PACKET_CLASS_SEND_CBUF,
 244            rx_stats.sendCbufPktAllocFailures);
 245     len += sprintf(buffer + len, "socketGreedy = %d\n", rx_stats.socketGreedy);
 246     len += sprintf(buffer + len, "bogusPacketOnRead = %d\n", rx_stats.bogusPacketOnRead);
 247     len += sprintf(buffer + len, "bogusHost = %d\n", rx_stats.bogusHost);
 248     len += sprintf(buffer + len, "noPacketOnRead = %d\n", rx_stats.noPacketOnRead);
 249     len += sprintf(buffer + len, "noPacketBuffersOnRead = %d\n",
 250            rx_stats.noPacketBuffersOnRead);
 251     len += sprintf(buffer + len, "selects = %d\n", rx_stats.selects);
 252     len += sprintf(buffer + len, "sendSelects = %d\n", rx_stats.sendSelects);
 253     for (i = 0; i < RX_N_PACKET_TYPES; i++)
 254         len += sprintf(buffer + len, "packetsRead[%d] = %d\n", i, rx_stats.packetsRead[i]);
 255     len += sprintf(buffer + len, "dataPacketsRead = %d\n", rx_stats.dataPacketsRead);
 256     len += sprintf(buffer + len, "ackPacketsRead = %d\n", rx_stats.ackPacketsRead);
 257     len += sprintf(buffer + len, "dupPacketsRead = %d\n", rx_stats.dupPacketsRead);
 258     len += sprintf(buffer + len, "spuriousPacketsRead = %d\n", rx_stats.spuriousPacketsRead);
 259     for (i = 0; i < RX_N_PACKET_TYPES; i++)
 260         len += sprintf(buffer + len, "packetsSent[%d] = %d\n", i, rx_stats.packetsSent[i]);
 261     len += sprintf(buffer + len, "ackPacketsSent = %d\n", rx_stats.ackPacketsSent);
 262     len += sprintf(buffer + len, "pingPacketsSent = %d\n", rx_stats.pingPacketsSent);
 263     len += sprintf(buffer + len, "abortPacketsSent = %d\n", rx_stats.abortPacketsSent);
 264     len += sprintf(buffer + len, "busyPacketsSent = %d\n", rx_stats.busyPacketsSent);
 265     len += sprintf(buffer + len, "dataPacketsSent = %d\n", rx_stats.dataPacketsSent);
 266     len += sprintf(buffer + len, "dataPacketsReSent = %d\n", rx_stats.dataPacketsReSent);
 267     len += sprintf(buffer + len, "dataPacketsPushed = %d\n", rx_stats.dataPacketsPushed);
 268     len += sprintf(buffer + len, "ignoreAckedPacket = %d\n", rx_stats.ignoreAckedPacket);
 269     len += sprintf(buffer + len, "totalRtt = %d sec, %d usec\n", rx_stats.totalRtt.sec,
 270            rx_stats.totalRtt.usec);
 271     len += sprintf(buffer + len, "minRtt = %d sec, %d usec\n", rx_stats.minRtt.sec,
 272            rx_stats.minRtt.usec);
 273     len += sprintf(buffer + len, "maxRtt = %d sec, %d usec\n", rx_stats.maxRtt.sec,
 274            rx_stats.maxRtt.usec);
 275     len += sprintf(buffer + len, "nRttSamples = %d\n", rx_stats.nRttSamples);
 276     len += sprintf(buffer + len, "nServerConns = %d\n", rx_stats.nServerConns);
 277     len += sprintf(buffer + len, "nClientConns = %d\n", rx_stats.nClientConns);
 278     len += sprintf(buffer + len, "nPeerStructs = %d\n", rx_stats.nPeerStructs);
 279     len += sprintf(buffer + len, "nCallStructs = %d\n", rx_stats.nCallStructs);
 280     len += sprintf(buffer + len, "nFreeCallStructs = %d\n", rx_stats.nFreeCallStructs);
 281     len += sprintf(buffer + len, "netSendFailures  = %d\n", rx_stats.netSendFailures);
 282     len += sprintf(buffer + len, "fatalErrors      = %d\n", rx_stats.fatalErrors);
 283
 284     if (offset >= len) {
 285         *start = buffer;
 286         *eof = 1;
 287         return 0;
 288     }
 289     *start = buffer + offset;
 290     if ((len -= offset) > count)
 291         return count;
 292     *eof = 1;
 293     return len;
 294 }
 295
 296 int
 297 rxproc_read(char *buffer, char **start, off_t offset, int count,
 298               int *eof, void *data)
 299 {
 300     int len, i, j;
 301     struct rx_peer *sep;
 302     void *ret = NULL;
 303     char tbuffer[16];
 304     afs_uint32 addr;
 305
 306     len = 0;
 307     len += sprintf(buffer + len, "rx_extraQuota = %d\n", rx_extraQuota);
 308     len += sprintf(buffer + len, "rx_extraPackets = %d\n", rx_extraPackets);
 309     len += sprintf(buffer + len, "rx_stackSize = %d\n", rx_stackSize);
 310     len += sprintf(buffer + len, "rx_connDeadTime = %d\n", rx_connDeadTime);
 311     len += sprintf(buffer + len, "rx_idleConnectionTime = %d\n", rx_idleConnectionTime);
 312     len += sprintf(buffer + len, "rx_idlePeerTime = %d\n", rx_idlePeerTime);
 313     len += sprintf(buffer + len, "rx_initSendWindow = %d\n", rx_initSendWindow);
 314     len += sprintf(buffer + len, "rxi_nSendFrags = %d\n", rxi_nSendFrags);
 315     len += sprintf(buffer + len, "rx_nPackets = %d\n", rx_nPackets);
 316     len += sprintf(buffer + len, "rx_nFreePackets = %d\n", rx_nFreePackets);
 317     len += sprintf(buffer + len, "rx_socket = 0x%x\n", rx_socket);
 318     len += sprintf(buffer + len, "rx_Port = %d\n", rx_port);
 319     for (i = 0; i < RX_N_PACKET_CLASSES; i++)
 320         len += sprintf(buffer + len, "\trx_packetQuota[%d] = %d\n", i, rx_packetQuota[i]);
 321
 322     len += sprintf(buffer + len, "rx_nextCid = 0x%x\n", rx_nextCid);
 323     len += sprintf(buffer + len, "rx_epoch = 0u%u\n", rx_epoch);
 324     len += sprintf(buffer + len, "rx_waitingForPackets = %x\n", rx_waitingForPackets);
 325     len += sprintf(buffer + len, "rxi_nCalls = %d\n", rxi_nCalls);
 326     len += sprintf(buffer + len, "rxi_dataQuota = %d\n", rxi_dataQuota);
 327     len += sprintf(buffer + len, "rxi_availProcs = %d\n", rxi_availProcs);
 328     len += sprintf(buffer + len, "rxi_totalMin = %d\n", rxi_totalMin);
 329     len += sprintf(buffer + len, "rxi_minDeficit = %d\n", rxi_minDeficit);
 330
 331     len += sprintf(buffer + len, "rxevent_nFree = %d\nrxevent_nPosted = %d\n", rxevent_nFree, rxevent_nPosted);
 332
 333     if (offset >= len) {
 334         *start = buffer;
 335         *eof = 1;
 336         return 0;
 337     }
 338     *start = buffer + offset;
 339     if ((len -= offset) > count)
 340         return count;
 341     *eof = 1;
 342     return len;
 343 }
 344
 345 int
 346 connproc_read(char *buffer, char **start, off_t offset, int count,
 347               int *eof, void *data)
 348 {
 349     int len, i, j;
 350     struct rx_connection *sep;
 351     void *ret = NULL;
 352     char tbuffer[16];
 353     afs_uint32 addr;
 354
 355     len = 0;
 356     for (i = 0, j = 0; i < 256; i++) {
 357         for (sep = rx_connHashTable[i]; sep; sep = sep->next, j++) {
 358             len += sprintf(buffer + len, "%lx: next=0x%lx, peer=0x%lx, epoch=0x%x, cid=0x%x, ackRate=%d\n",
 359                            sep, sep->next, sep->peer, sep->epoch, sep->cid,
 360                            sep->ackRate);
 361             len += sprintf(buffer + len, "\tcall[%x=%d, %x=%d, %x=%d, %x=%d]\n",
 362                            sep->call[0], sep->callNumber[0], sep->call[1],
 363                            sep->callNumber[1], sep->call[2],
 364                            sep->callNumber[2], sep->call[3],
 365                            sep->callNumber[3]);
 366             len += sprintf(buffer + len, "\ttimeout=%d, flags=0x%x, type=0x%x, serviceId=%d, service=0x%lx, refCount=%d\n",
 367                            sep->timeout, sep->flags, sep->type,
 368                            sep->serviceId, sep->service, sep->refCount);
 369             len += sprintf(buffer + len, "\tserial=%d, lastSerial=%d, secsUntilDead=%d, secsUntilPing=%d, secIndex=%d\n",
 370                            sep->serial, sep->lastSerial, sep->secondsUntilDead,
 371                            sep->secondsUntilPing, sep->securityIndex);
 372             len += sprintf(buffer + len, "\terror=%d, secObject=0x%lx, secData=0x%lx, secHeaderSize=%d, secmaxTrailerSize=%d\n",
 373                            sep->error, sep->securityObject, sep->securityData,
 374                            sep->securityHeaderSize,
 375                            sep->securityMaxTrailerSize);
 376             len += sprintf(buffer + len, "\tchallEvent=0x%lx, lastSendTime=0x%x, maxSerial=%d, hardDeadTime=%d\n",
 377                            sep->challengeEvent, sep->lastSendTime,
 378                            sep->maxSerial, sep->hardDeadTime);
 379             if (sep->flags & RX_CONN_MAKECALL_WAITING)
 380                 len += sprintf(buffer + len, "\t***** Conn in RX_CONN_MAKECALL_WAITING state *****\n");
 381 #ifdef RX_ENABLE_LOCKS
 382             len += sprintf(buffer + len, "\tcall_lock=%d, call_cv=%d, data_lock=%d, refCount=%d\n",
 383                            sep->conn_call_lock, sep->conn_call_cv,
 384                            sep->conn_data_lock, sep->refCount);
 385 #endif /* RX_ENABLE_LOCKS */
 386         }
 387     }
 388
 389     if (offset >= len) {
 390         *start = buffer;
 391         *eof = 1;
 392         return 0;
 393     }
 394     *start = buffer + offset;
 395     if ((len -= offset) > count)
 396         return count;
 397     *eof = 1;
 398     return len;
 399 }
 400
 401 int
 402 servicesproc_read(char *buffer, char **start, off_t offset, int count,
 403               int *eof, void *data)
 404 {
 405     int len, i, j;
 406     struct rx_service *sentry;
 407     void *ret = NULL;
 408     char tbuffer[16];
 409     afs_uint32 addr;
 410
 411     len = 0;
 412     for (i = 0, j = 0; i < RX_MAX_SERVICES; i++) {
 413         if (sentry = rx_services[i]) {
 414             j++;
 415             len += sprintf(buffer + len,
 416                            "\t%lx: serviceId=%d, port=%d, serviceName=%s, socket=0x%x\n",
 417                            sentry, sentry->serviceId, sentry->servicePort,
 418                            sentry->serviceName, sentry->socket);
 419             len += sprintf(buffer + len,
 420                            "\t\tnSecObj=%d, nReqRunning=%d, maxProcs=%d, minProcs=%d, connDeadTime=%d, idleDeadTime=%d\n",
 421                            sentry->nSecurityObjects, sentry->nRequestsRunning,
 422                            sentry->maxProcs, sentry->minProcs,
 423                            sentry->connDeadTime, sentry->idleDeadTime);
 424         }
 425     }
 426
 427     if (offset >= len) {
 428         *start = buffer;
 429         *eof = 1;
 430         return 0;
 431     }
 432     *start = buffer + offset;
 433     if ((len -= offset) > count)
 434         return count;
 435     *eof = 1;
 436     return len;
 437 }
 438
 439 int
 440 callproc_read(char *buffer, char **start, off_t offset, int count,
 441               int *eof, void *data)
 442 {
 443     int len, i, j, k;
 444     struct rx_connection *sep;
 445     void *ret = NULL;
 446     char tbuffer[16];
 447     afs_uint32 addr;
 448
 449     len = 0;
 450     for (i = 0, j = 0; i < 256; i++) {
 451         for (sep = rx_connHashTable[i]; sep; sep = sep->next) {
 452             for (k = 0; k < RX_MAXCALLS; k++) {
 453                 struct rx_call *call = sep->call[k];
 454                 if (call) {
 455                     j++;
 456                     len += sprintf(buffer + len,
 457                                    "%lx: conn=0x%lx, qiheader(0x%lx:0x%lx), tq(0x%lx:0x%lx), rq(0x%lx:0x%lx)\n",
 458                                    call, call->conn, call->queue_item_header.prev,
 459                                    call->queue_item_header.next, call->tq.prev,
 460                                    call->tq.next, call->rq.prev, call->rq.next);
 461                     len += sprintf(buffer + len,
 462                                    "\t: curvec=%d, curpos=%d, nLeft=%d, nFree=%d, currPacket=0x%lx, callNumber=0x%x\n",
 463                                    call->curvec, call->curpos, call->nLeft,
 464                                    call->nFree, call->currentPacket,
 465                                    call->callNumber);
 466                     len += sprintf(buffer + len,
 467                                    "\t: channel=%d, state=0x%x, mode=0x%x, flags=0x%x, localStatus=0x%x, remStatus=0x%x\n",
 468                                    call->channel, call->state, call->mode,
 469                                    call->flags, call->localStatus,
 470                                    call->remoteStatus);
 471                     len += sprintf(buffer + len,
 472                                    "\t: error=%d, timeout=0x%x, rnext=0x%x, rprev=0x%x, rwind=0x%x, tfirst=0x%x, tnext=0x%x\n",
 473                                    call->error, call->timeout, call->rnext,
 474                                    call->rprev, call->rwind, call->tfirst,
 475                                    call->tnext);
 476                     len += sprintf(buffer + len,
 477                                    "\t: twind=%d, resendEvent=0x%lx, timeoutEvent=0x%lx, keepAliveEvent=0x%lx, delayedAckEvent=0x%lx\n",
 478                                    call->twind, call->resendEvent,
 479                                    call->timeoutEvent, call->keepAliveEvent,
 480                                    call->delayedAckEvent);
 481                     len += sprintf(buffer + len,
 482                                    "\t: lastSendTime=0x%x, lastReceiveTime=0x%x, lastAcked=0x%x, startTime=0x%x, startWait=0x%x\n",
 483                                    call->lastSendTime, call->lastReceiveTime,
 484                                    call->lastAcked, call->startTime,
 485                                    call->startWait);
 486                     if (call->flags & RX_CALL_WAIT_PROC)
 487                         len += sprintf(buffer + len,
 488                                        "\t******** Call in RX_CALL_WAIT_PROC state **********\n");
 489                     if (call->flags & RX_CALL_WAIT_WINDOW_ALLOC)
 490                         len += sprintf(buffer + len,
 491                                        "\t******** Call in RX_CALL_WAIT_WINDOW_ALLOC state **********\n");
 492                     if (call->flags & RX_CALL_READER_WAIT)
 493                         len += sprintf(buffer + len,
 494                                        "\t******** Conn in RX_CALL_READER_WAIT state **********\n");
 495                     if (call->flags & RX_CALL_WAIT_PACKETS)
 496                         len += sprintf(buffer + len,
 497                                        "\t******** Conn in RX_CALL_WAIT_PACKETS state **********\n");
 498 #ifdef RX_ENABLE_LOCKS
 499                     len += sprintf(buffer + len,
 500                                    "\t: lock=0x%x, cv_twind=0x%x, cv_rq=0x%x, refCount= %d\n",
 501                                    call->lock, call->cv_twind, call->cv_rq,
 502                                    call->refCount);
 503 #endif /* RX_ENABLE_LOCKS */
 504                     len += sprintf(buffer + len, "\t: MTU=%d\n", call->MTU);
 505                 }
 506             }
 507         }
 508     }
 509
 510     if (offset >= len) {
 511         *start = buffer;
 512         *eof = 1;
 513         return 0;
 514     }
 515     *start = buffer + offset;
 516     if ((len -= offset) > count)
 517         return count;
 518     *eof = 1;
 519     return len;
 520 }
 521
 522 static struct proc_dir_entry *openafs_procfs;
 523
 524 static int
 525 afsproc_init()
 526 {
 527     struct proc_dir_entry *entry1;
 528     struct proc_dir_entry *entry;
 529
 530     openafs_procfs = proc_mkdir(PROC_FSDIRNAME, proc_root_fs);
 531     entry1 = create_proc_entry(PROC_SYSCALL_NAME, 0666, openafs_procfs);
 532
 533     entry1->proc_fops = &afs_syscall_fops;
 534
 535     entry1->owner = THIS_MODULE;
 536
 537     entry = create_proc_read_entry(PROC_CELLSERVDB_NAME, (S_IFREG|S_IRUGO), openafs_procfs, csdbproc_read, NULL);
 538
 539     entry = create_proc_read_entry(PROC_PEER_NAME, (S_IFREG|S_IRUGO), openafs_procfs, peerproc_read, NULL);
 540
 541     entry = create_proc_read_entry(PROC_CONN_NAME, (S_IFREG|S_IRUGO), openafs_procfs, connproc_read, NULL);
 542
 543     entry = create_proc_read_entry(PROC_CALL_NAME, (S_IFREG|S_IRUGO), openafs_procfs, connproc_read, NULL);
 544
 545     entry = create_proc_read_entry(PROC_RX_NAME, (S_IFREG|S_IRUGO), openafs_procfs, rxproc_read, NULL);
 546
 547     entry = create_proc_read_entry(PROC_SERVICES_NAME, (S_IFREG|S_IRUGO), openafs_procfs, servicesproc_read, NULL);
 548
 549     entry = create_proc_read_entry(PROC_RXSTATS_NAME, (S_IFREG|S_IRUGO), openafs_procfs, rxstatsproc_read, NULL);
 550
 551     return 0;
 552 }
 553
 554 static void
 555 afsproc_exit()
 556 {
 557     remove_proc_entry(PROC_RXSTATS_NAME, openafs_procfs);
 558     remove_proc_entry(PROC_SERVICES_NAME, openafs_procfs);
 559     remove_proc_entry(PROC_RX_NAME, openafs_procfs);
 560     remove_proc_entry(PROC_CALL_NAME, openafs_procfs);
 561     remove_proc_entry(PROC_CONN_NAME, openafs_procfs);
 562     remove_proc_entry(PROC_PEER_NAME, openafs_procfs);
 563     remove_proc_entry(PROC_CELLSERVDB_NAME, openafs_procfs);
 564     remove_proc_entry(PROC_SYSCALL_NAME, openafs_procfs);
 565     remove_proc_entry(PROC_FSDIRNAME, proc_root_fs);
 566 }
 567
 568 extern asmlinkage long
 569 afs_syscall(long syscall, long parm1, long parm2, long parm3, long parm4);
 570
 571 static int
 572 afs_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 573           unsigned long arg)
 574 {
 575
 576     struct afsprocdata sysargs;
 577
 578     if (cmd != VIOC_SYSCALL) return -EINVAL;
 579
 580     if (copy_from_user(&sysargs, (void *)arg, sizeof(struct afsprocdata)))
 581         return -EFAULT;
 582
 583     return afs_syscall(sysargs.syscall, sysargs.param1,
 584                        sysargs.param2, sysargs.param3, sysargs.param4);
 585 }
 586
 587 #ifdef AFS_IA64_LINUX20_ENV
 588
 589 asmlinkage long
 590 afs_syscall_stub(int r0, int r1, long r2, long r3, long r4, long gp)
 591 {
 592     __asm__ __volatile__("alloc r42 = ar.pfs, 8, 3, 6, 0\n\t" "mov r41 = b0\n\t"        /* save rp */
 593                          "mov out0 = in0\n\t" "mov out1 = in1\n\t" "mov out2 = in2\n\t" "mov out3 = in3\n\t" "mov out4 = in4\n\t" "mov out5 = gp\n\t"   /* save gp */
 594                          ";;\n" ".L1:    mov r3 = ip\n\t" ";;\n\t" "addl r15=.fptr_afs_syscall-.L1,r3\n\t" ";;\n\t" "ld8 r15=[r15]\n\t" ";;\n\t" "ld8 r16=[r15],8\n\t" ";;\n\t" "ld8 gp=[r15]\n\t" "mov b6=r16\n\t" "br.call.sptk.many b0 = b6\n\t" ";;\n\t" "mov ar.pfs = r42\n\t" "mov b0 = r41\n\t" "mov gp = r48\n\t"       /* restore gp */
 595                          "br.ret.sptk.many b0\n" ".fptr_afs_syscall:\n\t"
 596                          "data8 @fptr(afs_syscall)");
 597 }
 598
 599 asmlinkage long
 600 afs_xsetgroups_stub(int r0, int r1, long r2, long r3, long r4, long gp)
 601 {
 602     __asm__ __volatile__("alloc r42 = ar.pfs, 8, 3, 6, 0\n\t" "mov r41 = b0\n\t"        /* save rp */
 603                          "mov out0 = in0\n\t" "mov out1 = in1\n\t" "mov out2 = in2\n\t" "mov out3 = in3\n\t" "mov out4 = in4\n\t" "mov out5 = gp\n\t"   /* save gp */
 604                          ";;\n" ".L2:    mov r3 = ip\n\t" ";;\n\t" "addl r15=.fptr_afs_xsetgroups - .L2,r3\n\t" ";;\n\t" "ld8 r15=[r15]\n\t" ";;\n\t" "ld8 r16=[r15],8\n\t" ";;\n\t" "ld8 gp=[r15]\n\t" "mov b6=r16\n\t" "br.call.sptk.many b0 = b6\n\t" ";;\n\t" "mov ar.pfs = r42\n\t" "mov b0 = r41\n\t" "mov gp = r48\n\t"  /* restore gp */
 605                          "br.ret.sptk.many b0\n" ".fptr_afs_xsetgroups:\n\t"
 606                          "data8 @fptr(afs_xsetgroups)");
 607 }
 608
 609 struct fptr {
 610     void *ip;
 611     unsigned long gp;
 612 };
 613
 614 #endif /* AFS_IA64_LINUX20_ENV */
 615
 616 #ifdef AFS_LINUX24_ENV
 617 asmlinkage int (*sys_setgroups32p) (int gidsetsize,
 618                                     __kernel_gid32_t * grouplist);
 619 #endif /* AFS_LINUX24_ENV */
 620
 621 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_S390X_LINUX24_ENV)
 622 #define POINTER2SYSCALL (unsigned int)(unsigned long)
 623 #define SYSCALL2POINTER (void *)(long)
 624 #else
 625 #define POINTER2SYSCALL (void *)
 626 #define SYSCALL2POINTER (void *)
 627 #endif
 628
 629
 630 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
 631 int __init
 632 afs_init(void)
 633 #else
 634 int
 635 init_module(void)
 636 #endif
 637 {
 638 #if defined(AFS_IA64_LINUX20_ENV)
 639     unsigned long kernel_gp = 0;
 640     static struct fptr sys_setgroups;
 641 #endif /* defined(AFS_IA64_LINUX20_ENV) */
 642     extern long afs_xsetgroups();
 643 #if defined(__NR_setgroups32)
 644     extern int afs_xsetgroups32();
 645 #endif /* __NR_setgroups32 */
 646 #if defined(AFS_SPARC64_LINUX20_ENV) || defined (AFS_AMD64_LINUX20_ENV) || defined(AFS_PPC64_LINUX20_ENV)
 647     extern int afs32_xsetgroups();
 648 #if (defined(__NR_setgroups32) && defined(AFS_SPARC64_LINUX20_ENV))
 649     extern int afs32_xsetgroups32();
 650 #endif /* defined(__NR_setgroups32) && defined(AFS_SPARC64_LINUX20_ENV) */
 651 #if (defined(__NR_ia32_setgroups32) && defined(AFS_AMD64_LINUX20_ENV))
 652     extern int afs32_xsetgroups32();
 653 #endif /* (defined(__NR_ia32_setgroups32) && defined(AFS_AMD64_LINUX20_ENV) */
 654 #endif /* AFS_SPARC64_LINUX20_ENV || AFS_AMD64_LINUX20_ENV || AFS_PPC64_LINUX20_ENV */
 655
 656 #if !defined(EXPORTED_SYS_CALL_TABLE) || (defined(AFS_AMD64_LINUX20_ENV) && !defined(EXPORTED_IA32_SYS_CALL_TABLE))
 657     unsigned long *ptr;
 658     unsigned long offset=0;
 659     unsigned long datalen=0;
 660     int ret;
 661     unsigned long token=0;
 662     char *mod_name;
 663     unsigned long mod_start=0;
 664     unsigned long mod_end=0;
 665     char *sec_name;
 666     unsigned long sec_start=0;
 667     unsigned long sec_end=0;
 668     char *sym_name;
 669     unsigned long sym_start=0;
 670     unsigned long sym_end=0;
 671 #endif /* EXPORTED_SYS_CALL_TABLE */
 672
 673     RWLOCK_INIT(&afs_xosi, "afs_xosi");
 674
 675 #if !defined(AFS_LINUX24_ENV)
 676     /* obtain PAGE_OFFSET value */
 677     afs_linux_page_offset = get_page_offset();
 678
 679 #ifndef AFS_S390_LINUX22_ENV
 680     if (afs_linux_page_offset == 0) {
 681         /* couldn't obtain page offset so can't continue */
 682         printf("afs: Unable to obtain PAGE_OFFSET. Exiting..");
 683         return -EIO;
 684     }
 685 #endif /* AFS_S390_LINUX22_ENV */
 686 #endif /* !defined(AFS_LINUX24_ENV) */
 687
 688 #ifndef EXPORTED_SYS_CALL_TABLE
 689     sys_call_table = 0;
 690
 691 #ifdef EXPORTED_KALLSYMS_SYMBOL
 692     ret = 1;
 693     token = 0;
 694     while (ret) {
 695         sym_start = 0;
 696         ret =
 697             kallsyms_symbol_to_address("sys_call_table", &token, &mod_name,
 698                                        &mod_start, &mod_end, &sec_name,
 699                                        &sec_start, &sec_end, &sym_name,
 700                                        &sym_start, &sym_end);
 701         if (ret && !strcmp(mod_name, "kernel"))
 702             break;
 703     }
 704     if (ret && sym_start) {
 705         sys_call_table = sym_start;
 706     }
 707 #elif defined(EXPORTED_KALLSYMS_ADDRESS)
 708     ret =
 709         kallsyms_address_to_symbol((unsigned long)&init_mm, &mod_name,
 710                                    &mod_start, &mod_end, &sec_name,
 711                                    &sec_start, &sec_end, &sym_name,
 712                                    &sym_start, &sym_end);
 713     ptr = (unsigned long *)sec_start;
 714     datalen = (sec_end - sec_start) / sizeof(unsigned long);
 715 #elif defined(AFS_IA64_LINUX20_ENV)
 716     ptr = (unsigned long *)(&sys_close - 0x180000);
 717     datalen = 0x180000 / sizeof(ptr);
 718 #elif defined(AFS_AMD64_LINUX20_ENV)
 719     ptr = (unsigned long *)&init_mm;
 720     datalen = 0x360000 / sizeof(ptr);
 721 #else
 722     ptr = (unsigned long *)&init_mm;
 723     datalen = 16384;
 724 #endif
 725     for (offset = 0; offset < datalen; ptr++, offset++) {
 726 #if defined(AFS_IA64_LINUX20_ENV)
 727         unsigned long close_ip =
 728             (unsigned long)((struct fptr *)&sys_close)->ip;
 729         unsigned long chdir_ip =
 730             (unsigned long)((struct fptr *)&sys_chdir)->ip;
 731         unsigned long write_ip =
 732             (unsigned long)((struct fptr *)&sys_write)->ip;
 733         if (ptr[0] == close_ip && ptr[__NR_chdir - __NR_close] == chdir_ip
 734             && ptr[__NR_write - __NR_close] == write_ip) {
 735             sys_call_table = (void *)&(ptr[-1 * (__NR_close - 1024)]);
 736             break;
 737         }
 738 #elif defined(EXPORTED_SYS_WAIT4) && defined(EXPORTED_SYS_CLOSE)
 739         if (ptr[0] == (unsigned long)&sys_close
 740             && ptr[__NR_wait4 - __NR_close] == (unsigned long)&sys_wait4) {
 741             sys_call_table = ptr - __NR_close;
 742             break;
 743         }
 744 #elif defined(EXPORTED_SYS_CHDIR) && defined(EXPORTED_SYS_CLOSE)
 745         if (ptr[0] == (unsigned long)&sys_close
 746             && ptr[__NR_chdir - __NR_close] == (unsigned long)&sys_chdir) {
 747             sys_call_table = ptr - __NR_close;
 748             break;
 749         }
 750 #elif defined(EXPORTED_SYS_OPEN)
 751         if (ptr[0] == (unsigned long)&sys_exit
 752             && ptr[__NR_open - __NR_exit] == (unsigned long)&sys_open) {
 753             sys_call_table = ptr - __NR_exit;
 754             break;
 755         }
 756 #else /* EXPORTED_SYS_OPEN */
 757         break;
 758 #endif /* EXPORTED_KALLSYMS_ADDRESS */
 759     }
 760 #ifdef EXPORTED_KALLSYMS_ADDRESS
 761     ret =
 762         kallsyms_address_to_symbol((unsigned long)sys_call_table, &mod_name,
 763                                    &mod_start, &mod_end, &sec_name,
 764                                    &sec_start, &sec_end, &sym_name,
 765                                    &sym_start, &sym_end);
 766     if (ret && strcmp(sym_name, "sys_call_table"))
 767         sys_call_table = 0;
 768 #endif /* EXPORTED_KALLSYMS_ADDRESS */
 769     if (!sys_call_table) {
 770         printf("Failed to find address of sys_call_table\n");
 771     } else {
 772         printf("Found sys_call_table at %x\n", sys_call_table);
 773 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_S390X_LINUX24_ENV)
 774         error cant support this yet.;
 775 #endif /* AFS_SPARC64_LINUX20_ENV */
 776 #endif /* EXPORTED_SYS_CALL_TABLE */
 777
 778 #ifdef AFS_AMD64_LINUX20_ENV
 779 #ifndef EXPORTED_IA32_SYS_CALL_TABLE
 780         ia32_sys_call_table = 0;
 781 #ifdef EXPORTED_KALLSYMS_SYMBOL
 782         ret = 1;
 783         token = 0;
 784         while (ret) {
 785             sym_start = 0;
 786             ret = kallsyms_symbol_to_address("ia32_sys_call_table", &token,
 787                                              &mod_name, &mod_start, &mod_end,
 788                                              &sec_name, &sec_start, &sec_end,
 789                                              &sym_name, &sym_start, &sym_end);
 790             if (ret && !strcmp(mod_name, "kernel"))
 791                 break;
 792         }
 793         if (ret && sym_start) {
 794             ia32_sys_call_table = sym_start;
 795         }
 796 #else /* EXPORTED_KALLSYMS_SYMBOL */
 797 #ifdef EXPORTED_KALLSYMS_ADDRESS
 798         ret = kallsyms_address_to_symbol((unsigned long)
 799                                          &interruptible_sleep_on,
 800                                          &mod_name, &mod_start, &mod_end,
 801                                          &sec_name, &sec_start, &sec_end,
 802                                          &sym_name, &sym_start, &sym_end);
 803         ptr = (unsigned long *)sec_start;
 804         datalen = (sec_end - sec_start) / sizeof(unsigned long);
 805 #else /* EXPORTED_KALLSYMS_ADDRESS */
 806 #if defined(AFS_AMD64_LINUX20_ENV)
 807         ptr = (unsigned long *)&interruptible_sleep_on;
 808         datalen = 0x180000 / sizeof(ptr);
 809 #else /* AFS_AMD64_LINUX20_ENV */
 810         ptr = (unsigned long *)&interruptible_sleep_on;
 811         datalen = 16384;
 812 #endif /* AFS_AMD64_LINUX20_ENV */
 813 #endif /* EXPORTED_KALLSYMS_ADDRESS */
 814         for (offset = 0; offset < datalen; ptr++, offset++) {
 815             if (ptr[0] == (unsigned long)&sys_exit
 816                 && ptr[__NR_ia32_open - __NR_ia32_exit] ==
 817                 (unsigned long)&sys_open) {
 818                     ia32_sys_call_table = ptr - __NR_ia32_exit;
 819                     break;
 820             }
 821         }
 822 #ifdef EXPORTED_KALLSYMS_ADDRESS
 823         ret = kallsyms_address_to_symbol((unsigned long)ia32_sys_call_table,
 824                                          &mod_name, &mod_start, &mod_end,
 825                                          &sec_name, &sec_start, &sec_end,
 826                                          &sym_name, &sym_start, &sym_end);
 827         if (ret && strcmp(sym_name, "ia32_sys_call_table"))
 828             ia32_sys_call_table = 0;
 829 #endif /* EXPORTED_KALLSYMS_ADDRESS */
 830 #endif /* EXPORTED_KALLSYMS_SYMBOL */
 831         if (!ia32_sys_call_table) {
 832             printf("Warning: Failed to find address of ia32_sys_call_table\n");
 833         } else {
 834             printf("Found ia32_sys_call_table at %x\n", ia32_sys_call_table);
 835         }
 836 #else
 837         printf("Found ia32_sys_call_table at %x\n", ia32_sys_call_table);
 838 #endif /* IA32_SYS_CALL_TABLE */
 839 #endif
 840
 841         /* Initialize pointers to kernel syscalls. */
 842 #if !defined(AFS_LINUX24_ENV)
 843         sys_settimeofdayp = SYSCALL2POINTER sys_call_table[_S(__NR_settimeofday)];
 844 #endif /* AFS_IA64_LINUX20_ENV */
 845
 846         /* setup AFS entry point. */
 847         if (
 848 #if defined(AFS_IA64_LINUX20_ENV)
 849                 SYSCALL2POINTER sys_call_table[__NR_afs_syscall - 1024]
 850 #else
 851                 SYSCALL2POINTER sys_call_table[_S(__NR_afs_syscall)]
 852 #endif
 853                 == afs_syscall) {
 854             printf("AFS syscall entry point already in use!\n");
 855             return -EBUSY;
 856         }
 857 #if defined(AFS_IA64_LINUX20_ENV)
 858         afs_ni_syscall = sys_call_table[__NR_afs_syscall - 1024];
 859         sys_call_table[__NR_afs_syscall - 1024] =
 860                 POINTER2SYSCALL((struct fptr *)afs_syscall_stub)->ip;
 861 #else /* AFS_IA64_LINUX20_ENV */
 862         afs_ni_syscall = sys_call_table[_S(__NR_afs_syscall)];
 863         sys_call_table[_S(__NR_afs_syscall)] = POINTER2SYSCALL afs_syscall;
 864 #ifdef AFS_SPARC64_LINUX20_ENV
 865         afs_ni_syscall32 = sys_call_table32[__NR_afs_syscall];
 866         sys_call_table32[__NR_afs_syscall] = POINTER2SYSCALL afs_syscall32;
 867 #endif
 868 #endif /* AFS_IA64_LINUX20_ENV */
 869 #ifdef AFS_AMD64_LINUX20_ENV
 870         if (ia32_sys_call_table) {
 871             ia32_ni_syscall = ia32_sys_call_table[__NR_ia32_afs_syscall];
 872             ia32_sys_call_table[__NR_ia32_afs_syscall] =
 873                     POINTER2SYSCALL afs_syscall;
 874         }
 875 #endif /* AFS_S390_LINUX22_ENV */
 876 #ifndef EXPORTED_SYS_CALL_TABLE
 877     }
 878 #endif /* EXPORTED_SYS_CALL_TABLE */
 879     osi_Init();
 880     register_filesystem(&afs_fs_type);
 881
 882     /* Intercept setgroups calls */
 883     if (sys_call_table) {
 884 #if defined(AFS_IA64_LINUX20_ENV)
 885     sys_setgroupsp = (void *)&sys_setgroups;
 886
 887     ((struct fptr *)sys_setgroupsp)->ip =
 888         SYSCALL2POINTER sys_call_table[__NR_setgroups - 1024];
 889     ((struct fptr *)sys_setgroupsp)->gp = kernel_gp;
 890
 891     sys_call_table[__NR_setgroups - 1024] =
 892         POINTER2SYSCALL((struct fptr *)afs_xsetgroups_stub)->ip;
 893 #else /* AFS_IA64_LINUX20_ENV */
 894     sys_setgroupsp = SYSCALL2POINTER sys_call_table[_S(__NR_setgroups)];
 895     sys_call_table[_S(__NR_setgroups)] = POINTER2SYSCALL afs_xsetgroups;
 896 #ifdef AFS_SPARC64_LINUX20_ENV
 897     sys32_setgroupsp = SYSCALL2POINTER sys_call_table32[__NR_setgroups];
 898     sys_call_table32[__NR_setgroups] = POINTER2SYSCALL afs32_xsetgroups;
 899 #endif /* AFS_SPARC64_LINUX20_ENV */
 900 #if defined(__NR_setgroups32)
 901     sys_setgroups32p = SYSCALL2POINTER sys_call_table[__NR_setgroups32];
 902     sys_call_table[__NR_setgroups32] = POINTER2SYSCALL afs_xsetgroups32;
 903 #ifdef AFS_SPARC64_LINUX20_ENV
 904         sys32_setgroups32p =
 905             SYSCALL2POINTER sys_call_table32[__NR_setgroups32];
 906         sys_call_table32[__NR_setgroups32] =
 907             POINTER2SYSCALL afs32_xsetgroups32;
 908 #endif /* AFS_SPARC64_LINUX20_ENV */
 909 #endif /* __NR_setgroups32 */
 910 #ifdef AFS_AMD64_LINUX20_ENV
 911     if (ia32_sys_call_table) {
 912         sys32_setgroupsp =
 913             SYSCALL2POINTER ia32_sys_call_table[__NR_ia32_setgroups];
 914         ia32_sys_call_table[__NR_ia32_setgroups] =
 915             POINTER2SYSCALL afs32_xsetgroups;
 916 #if defined(__NR_ia32_setgroups32)
 917         sys32_setgroups32p =
 918             SYSCALL2POINTER ia32_sys_call_table[__NR_ia32_setgroups32];
 919         ia32_sys_call_table[__NR_ia32_setgroups32] =
 920             POINTER2SYSCALL afs32_xsetgroups32;
 921 #endif /* __NR_ia32_setgroups32 */
 922     }
 923 #endif /* AFS_AMD64_LINUX20_ENV */
 924 #endif /* AFS_IA64_LINUX20_ENV */
 925
 926     }
 927
 928     osi_sysctl_init();
 929     afsproc_init();
 930
 931     return 0;
 932 }
 933
 934 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
 935 void __exit
 936 afs_cleanup(void)
 937 #else
 938 void
 939 cleanup_module(void)
 940 #endif
 941 {
 942     struct task_struct *t;
 943
 944     osi_sysctl_clean();
 945     if (sys_call_table) {
 946 #if defined(AFS_IA64_LINUX20_ENV)
 947     sys_call_table[__NR_setgroups - 1024] =
 948         POINTER2SYSCALL((struct fptr *)sys_setgroupsp)->ip;
 949     sys_call_table[__NR_afs_syscall - 1024] = afs_ni_syscall;
 950 #else /* AFS_IA64_LINUX20_ENV */
 951     sys_call_table[_S(__NR_setgroups)] = POINTER2SYSCALL sys_setgroupsp;
 952     sys_call_table[_S(__NR_afs_syscall)] = afs_ni_syscall;
 953 # ifdef AFS_SPARC64_LINUX20_ENV
 954     sys_call_table32[__NR_setgroups] = POINTER2SYSCALL sys32_setgroupsp;
 955     sys_call_table32[__NR_afs_syscall] = afs_ni_syscall32;
 956 # endif
 957 # if defined(__NR_setgroups32)
 958     sys_call_table[__NR_setgroups32] = POINTER2SYSCALL sys_setgroups32p;
 959 # ifdef AFS_SPARC64_LINUX20_ENV
 960         sys_call_table32[__NR_setgroups32] =
 961             POINTER2SYSCALL sys32_setgroups32p;
 962 # endif
 963 # endif
 964 #endif /* AFS_IA64_LINUX20_ENV */
 965 #ifdef AFS_AMD64_LINUX20_ENV
 966     if (ia32_sys_call_table) {
 967         ia32_sys_call_table[__NR_ia32_setgroups] =
 968             POINTER2SYSCALL sys32_setgroupsp;
 969         ia32_sys_call_table[__NR_ia32_afs_syscall] =
 970             POINTER2SYSCALL ia32_ni_syscall;
 971 # if defined(__NR_setgroups32)
 972         ia32_sys_call_table[__NR_ia32_setgroups32] =
 973             POINTER2SYSCALL sys32_setgroups32p;
 974 #endif
 975     }
 976 #endif
 977     }
 978     unregister_filesystem(&afs_fs_type);
 979
 980     osi_linux_free_inode_pages();       /* Invalidate all pages using AFS inodes. */
 981     osi_linux_free_afs_memory();
 982
 983     afsproc_exit();
 984     return;
 985 }
 986
 987 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
 988 module_init(afs_init);
 989 module_exit(afs_cleanup);
 990 #endif
 991
 992
 993 #if !defined(AFS_LINUX24_ENV)
 994 static long
 995 get_page_offset(void)
 996 {
 997 #if defined(AFS_PPC_LINUX22_ENV) || defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_SPARC_LINUX20_ENV) || defined(AFS_ALPHA_LINUX20_ENV) || defined(AFS_S390_LINUX22_ENV) || defined(AFS_IA64_LINUX20_ENV) || defined(AFS_PARISC_LINUX24_ENV) || defined(AFS_AMD64_LINUX20_ENV) || defined(AFS_PPC64_LINUX20_ENV)
 998     return PAGE_OFFSET;
 999 #else
1000     struct task_struct *p, *q;
1001
1002     /* search backward thru the circular list */
1003 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
1004     read_lock(&tasklist_lock);
1005 #endif
1006     /* search backward thru the circular list */
1007 #ifdef DEFINED_PREV_TASK
1008     for (q = current; p = q; q = prev_task(p)) {
1009 #else
1010     for (p = current; p; p = p->prev_task) {
1011 #endif
1012         if (p->pid == 1) {
1013 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
1014             read_unlock(&tasklist_lock);
1015 #endif
1016             return p->addr_limit.seg;
1017         }
1018     }
1019
1020 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
1021     read_unlock(&tasklist_lock);
1022 #endif
1023     return 0;
1024 #endif
1025 }
1026 #endif /* !AFS_LINUX24_ENV */