Attachment #348842 for bug #470896




++ b/vmnet-only/bridge.c

static Bool VNetBridgeIsDeviceWireless(struct net_device *dev);
static void VNetBridgePortsChanged(VNetJack *this);
static int  VNetBridgeIsBridged(VNetJack *this);
static int  VNetBridgeProcRead(char *page, char **start, off_t off,
                               int count, int *eof, void *data);
static void VNetBridgeComputeHeaderPosIPv6(struct sk_buff *skb);
static PacketStatus VNetCallSMACFunc(struct SMACState *state,
                                     struct sk_buff **skb, void *startOfData,

/*
 *----------------------------------------------------------------------
 *
 * VNetBridgeProcShow --
 *
 *      Callback for read operation on this bridge entry in vnets proc fs.
 *
 * Results:
 *      Length of read operation.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetBridgeProcShow(struct seq_file *seqf, // IN/OUT: buffer to write into
                   void    *data)   // IN: client data - pointer to bridge
{
   VNetBridge *bridge = (VNetBridge*)data;

   if (!bridge) {
      return 0;
   }

   VNetPrintPort(&bridge->port, seqf);

   seq_printf(seqf, "dev %s ", bridge->name);

   seq_printf(seqf, "\n");

   return 0;
}

static int proc_bridge_open(struct inode *inode, struct file *file)
{
       return single_open(file, VNetBridgeProcShow, PDE_DATA(inode));
}

static const struct file_operations proc_bridge_fops = {
       .open           = proc_bridge_open,
       .read           = seq_read,
       .llseek         = seq_lseek,
       .release        = seq_release,
};

/*
 *----------------------------------------------------------------------
 *
 * VNetBridge_Create --
 *
 *      Creates a bridge. Allocates struct, allocates internal device,

    * Make proc entry for this jack.
    */

   retval = VNetProc_MakeEntryOps(bridge->port.jack.name, S_IFREG,
                               &bridge->port.jack.procEntry, &proc_bridge_fops, bridge);
   if (retval) {
      if (retval == -ENXIO) {
         bridge->port.jack.procEntry = NULL;
      } else {
         goto out;
      }
   } else {
      bridge->port.jack.procEntry->read_proc = VNetBridgeProcRead;
      bridge->port.jack.procEntry->data = bridge;
   }

   /*

   return 0;
}

++ b/vmnet-only/driver.c
/*
 *----------------------------------------------------------------------
 *
 * VNetBridgeProcRead --
 *
 *      Callback for read operation on this bridge entry in vnets proc fs.
 *
 * Results:
 *      Length of read operation.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetBridgeProcRead(char    *page,   // IN/OUT: buffer to write into
                   char   **start,  // OUT: 0 if file < 4k, else offset into page
                   off_t    off,    // IN: (unused) offset of read into the file
                   int      count,  // IN: (unused) maximum number of bytes to read
                   int     *eof,    // OUT: TRUE if there is nothing more to read
                   void    *data)   // IN: client data - pointer to bridge
{
   VNetBridge *bridge = (VNetBridge*)data;
   int len = 0;

   if (!bridge) {
      return len;
   }

   len += VNetPrintPort(&bridge->port, page+len);

   len += sprintf(page+len, "dev %s ", bridge->name);

   len += sprintf(page+len, "\n");

   *start = 0;
   *eof   = 1;
   return len;
}
-- a/vmnet-only/driver.c

 *----------------------------------------------------------------------
 */

void
VNetPrintJack(const VNetJack *jack, // IN: jack
              struct seq_file *seqf)  // OUT: info about jack
{
   int len = 0;

   read_lock(&vnetPeerLock);
   if (!jack->peer) {
      seq_printf(seqf, "connected not ");
   } else {
      seq_printf(seqf, "connected %s ", jack->peer->name);
   }
   read_unlock(&vnetPeerLock);

   return len;
}



 *----------------------------------------------------------------------
 */

void
VNetPrintPort(const VNetPort *port, // IN: port
              struct seq_file *seqf)  // OUT: info about port
{
   VNetPrintJack(&port->jack, seqf);

   seq_printf(seqf, "mac %02x:%02x:%02x:%02x:%02x:%02x ",

   len += sprintf(buf+len, "mac %02x:%02x:%02x:%02x:%02x:%02x ",
                  port->paddr[0], port->paddr[1], port->paddr[2],
                  port->paddr[3], port->paddr[4], port->paddr[5]);

   seq_printf(seqf, "ladrf %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
                  port->ladrf[0], port->ladrf[1], port->ladrf[2],
                  port->ladrf[3], port->ladrf[4], port->ladrf[5],
                  port->ladrf[6], port->ladrf[7]);

   seq_printf(seqf, "flags IFF_RUNNING");

   if (port->flags & IFF_UP) {
      seq_printf(seqf, ",IFF_UP");
   }

   if (port->flags & IFF_BROADCAST) {
      seq_printf(seqf, ",IFF_BROADCAST");
   }

   if (port->flags & IFF_DEBUG) {
      seq_printf(seqf, ",IFF_DEBUG");
   }

   if (port->flags & IFF_PROMISC) {
      seq_printf(seqf, ",IFF_PROMISC");
   }

   if (port->flags & IFF_MULTICAST) {
      seq_printf(seqf, ",IFF_MULTICAST");
   }

   if (port->flags & IFF_ALLMULTI) {
      seq_printf(seqf, ",IFF_ALLMULTI");
   }

   seq_printf(seqf, " ");

   return len;
}


++ b/vmnet-only/hub.c

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/poll.h>
#include <linux/seq_file.h>

#include <linux/netdevice.h>
#include <linux/etherdevice.h>

static Bool VNetHubCycleDetect(VNetJack *this, int generation);
static void VNetHubPortsChanged(VNetJack *this);
static int  VNetHubIsBridged(VNetJack *this);
static int  VNetHubProcRead(char *page, char **start, off_t off,
                            int count, int *eof, void *data);

static VNetHub *vnetHub;
static DEFINE_SPINLOCK(vnetHubLock);

/*
 *----------------------------------------------------------------------
 *
 * VNetHubProcShow --
 *
 *      Callback for read operation on hub entry in vnets proc fs.
 *
 * Results:
 *      Length of read operation.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetHubProcShow(struct seq_file  *seqf,   // IN/OUT: buffer to write into
                void    *data)   // IN: client data - not used
{
   VNetJack *jack = (VNetJack*)data;
   VNetHub *hub;

   if (!jack || !jack->private) {
      return 0;
   }
   hub = (VNetHub*)jack->private;

   VNetPrintJack(jack, seqf);

   seq_printf(seqf, "tx %u ", hub->stats[jack->index].tx);
   seq_printf(seqf, "\n");
   return 0;
}

static int proc_hub_open(struct inode *inode, struct file *file)
{
       return single_open(file, VNetHubProcShow, PDE_DATA(inode));
}

static const struct file_operations proc_hub_fops = {
       .open           = proc_hub_open,
       .read           = seq_read,
       .llseek         = seq_lseek,
       .release        = seq_release,
};

/*
 *----------------------------------------------------------------------
 *
 * VNetHubAlloc --
 *
 *      Allocate a jack on this hub.

          * Make proc entry for this jack.
          */

         retval = VNetProc_MakeEntryOps(jack->name, S_IFREG, &jack->procEntry, &proc_hub_fops, jack);
         if (retval) {
            if (retval == -ENXIO) {
               jack->procEntry = NULL;

	       hub->used[i] = FALSE;
               return NULL;
            }
         } else {
            jack->procEntry->read_proc = VNetHubProcRead;
            jack->procEntry->data = jack;
         }

         /*

}


++ b/vmnet-only/netif.c
 *----------------------------------------------------------------------
 *
 * VNetHubProcRead --
 *
 *      Callback for read operation on hub entry in vnets proc fs.
 *
 * Results:
 *      Length of read operation.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetHubProcRead(char    *page,   // IN/OUT: buffer to write into
                char   **start,  // OUT: 0 if file < 4k, else offset into page
                off_t    off,    // IN: offset of read into the file
                int      count,  // IN: maximum number of bytes to read
                int     *eof,    // OUT: TRUE if there is nothing more to read
                void    *data)   // IN: client data - not used
{
   VNetJack *jack = (VNetJack*)data;
   VNetHub *hub;
   int len = 0;

   if (!jack || !jack->private) {
      return len;
   }
   hub = (VNetHub*)jack->private;

   len += VNetPrintJack(jack, page+len);

   len += sprintf(page+len, "tx %u ", hub->stats[jack->index].tx);

   len += sprintf(page+len, "\n");

   *start = 0;
   *eof   = 1;
   return len;
}
-- a/vmnet-only/netif.c

static struct net_device_stats *VNetNetifGetStats(struct net_device *dev);
static int  VNetNetifSetMAC(struct net_device *dev, void *addr);
static void VNetNetifSetMulticast(struct net_device *dev);
static int  VNetNetIfProcRead(char *page, char **start, off_t off,
                              int count, int *eof, void *data);

/*
 *----------------------------------------------------------------------


}

/*
 *----------------------------------------------------------------------
 *
 * VNetNetIfProcShow --
 *
 *      Callback for read operation on this netif entry in vnets proc fs.
 *
 * Results: 
 *      Length of read operation.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetNetIfProcShow(struct seq_file *seqf, // IN/OUT: buffer to write into
                  void   *data)  // IN: client data
{
   VNetNetIF *netIf = data; 
   
   if (!netIf) {
      return 0;
   }
   
   VNetPrintPort(&netIf->port, seqf);

   seq_printf(seqf, "dev %s ", netIf->dev->name);
   
   seq_printf(seqf, "\n");

   return 0;
}

static int proc_netif_open(struct inode *inode, struct file *file)
{
       return single_open(file, VNetNetIfProcShow, PDE_DATA(inode));
}

static const struct file_operations proc_netif_fops = {
       .open           = proc_netif_open,
       .read           = seq_read,
       .llseek         = seq_lseek,
       .release        = seq_release,
};


/*
 *----------------------------------------------------------------------

    * Make proc entry for this jack.
    */

   retval = VNetProc_MakeEntryOps(netIf->port.jack.name, S_IFREG,
                               &netIf->port.jack.procEntry, &proc_netif_fops, netIf);
   if (retval) {
      netIf->port.jack.procEntry = NULL;
      if (retval != -ENXIO) {
         goto outFreeDev;
      }
   } else {
      netIf->port.jack.procEntry->read_proc = VNetNetIfProcRead;
      netIf->port.jack.procEntry->data = netIf;
   }

   /*

   return &netIf->stats;
}

++ b/vmnet-only/procfs.c
/*
 *----------------------------------------------------------------------
 *
 * VNetNetIfProcRead --
 *
 *      Callback for read operation on this netif entry in vnets proc fs.
 *
 * Results: 
 *      Length of read operation.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetNetIfProcRead(char   *page,  // IN/OUT: buffer to write into
                  char  **start, // OUT: 0 if file < 4k, else offset into page
                  off_t   off,   // IN: (unused) offset of read into the file
                  int     count, // IN: (unused) maximum number of bytes to read
                  int    *eof,   // OUT: TRUE if there is nothing more to read
                  void   *data)  // IN: client data
{
   VNetNetIF *netIf = data; 
   int len = 0;
   
   if (!netIf) {
      return len;
   }
   
   len += VNetPrintPort(&netIf->port, page+len);

   len += sprintf(page+len, "dev %s ", netIf->dev->name);
   
   len += sprintf(page+len, "\n");

   *start = 0;
   *eof   = 1;
   return len;
}
-- a/vmnet-only/procfs.c


#if defined(CONFIG_PROC_FS)

static int VNetProcMakeEntryInt(VNetProcEntry *parent, char *name, int mode,
                                VNetProcEntry **ret);
static void VNetProcRemoveEntryInt(VNetProcEntry *node, VNetProcEntry *parent);

static VNetProcEntry *base = NULL;



int
VNetProc_Init(void)
{
	base = proc_mkdir("vmnet", NULL);
	if(IS_ERR(base)) {
		base = NULL;
		return PTR_ERR(base);
	}
	return 0;
}



void
VNetProc_Cleanup(void)
{
   proc_remove(base);
   base = NULL;
}

/*
 *----------------------------------------------------------------------
 *
 * VNetProc_MakeEntryOps --
 *
 *      Make an entry in the vnets proc file system.
 *

 */

int
VNetProc_MakeEntryOps(char            *name,  // IN:
		     char            *name,  // IN:
		     int              mode,  // IN:
		     VNetProcEntry  **ret,
		     const struct file_operations *fops,
		     void *data
		     )   // OUT:
{
   VNetProcEntry *ent;
   ent = proc_create_data(name, mode, base, fops, data);
   *ret = ent;
   if (!ent)
      return -ENOMEM;
   return 0;
}


/*
 *----------------------------------------------------------------------
 *
 * VNetProcRemoveEntryInt --
 *
 *      Remove a previously installed proc entry.
 *
 * Results: 
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
VNetProcRemoveEntryInt(VNetProcEntry *node,
                       VNetProcEntry *parent)
{
   if (node) {
      remove_proc_entry(node->name, parent);
   }
}


/*
 *----------------------------------------------------------------------
 *
 * VNetProc_MakeEntry --
 *
 *      Make an entry in the vnets proc file system.
 *
 * Results: 
 *      errno. If errno is 0 and ret is non NULL then ret is filled
 *      in with the resulting proc entry.
 *      
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetProc_MakeEntry(char            *name,  // IN:
		   int              mode,  // IN:
		   VNetProcEntry  **ret)   // OUT:
{
   return VNetProcMakeEntryInt(base, name, mode, ret);
}


/*
 *----------------------------------------------------------------------
 *

void
VNetProc_RemoveEntry(VNetProcEntry *node)
{
	if(node)
		proc_remove(node);
}



}


/*
 *----------------------------------------------------------------------
 *
 * VNetProc_MakeEntry --
 *
 *      Make an entry in the vnets proc file system.
 *
 * Results: 
 *      errno. If errno is 0 and ret is non NULL then ret is filled
 *      in with the resulting proc entry.
 *      
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

int
VNetProc_MakeEntry(char            *name,
                   int              mode,
                   VNetProcEntry  **ret)
{
   return -ENXIO;
}


/*
 *----------------------------------------------------------------------
++ b/vmnet-only/userif.c

/*
 *----------------------------------------------------------------------
 *
 * VNetUserIfProcShow --
 *
 *      Callback for read operation on this userif entry in vnets proc fs.
 *

 */

static int
VNetUserIfProcShow(struct seq_file    *seqf,  // IN/OUT: buffer to write into
                   char   **start, // OUT: 0 if file < 4k, else offset into
                                   //      page
                   off_t    off,   // IN: offset of read into the file
                   int      count, // IN: maximum number of bytes to read
                   int     *eof,   // OUT: TRUE if there is nothing more to
                                   //      read
                   void    *data)  // IN: client data - not used
{
   VNetUserIF *userIf = (VNetUserIF*)data; 
   int len = 0;
   
   if (!userIf) {
      return 0;
   }
   
   VNetPrintPort(&userIf->port, seqf);
   
   seq_printf(seqf, "read %u written %u queued %u ",
                  userIf->stats.read,
                  userIf->stats.written,
                  userIf->stats.queued);
   
   seq_printf(seqf, 
		  "dropped.down %u dropped.mismatch %u "
		  "dropped.overflow %u dropped.largePacket %u",
                  userIf->stats.droppedDown,

                  userIf->stats.droppedOverflow,
		  userIf->stats.droppedLargePacket);

   seq_printf(seqf, "\n");
   
   return 0;
}

static int proc_userif_open(struct inode *inode, struct file *file)
{
       return single_open(file, VNetUserIfProcShow, PDE_DATA(inode));
}

static const struct file_operations proc_userif_fops = {
       .open           = proc_userif_open,
       .read           = seq_read,
       .llseek         = seq_lseek,
       .release        = seq_release,
};


/*
 *----------------------------------------------------------------------

    * Make proc entry for this jack.
    */
   
   retval = VNetProc_MakeEntryOps(userIf->port.jack.name, S_IFREG,
                               &userIf->port.jack.procEntry, &proc_userif_fops, userIf);
   if (retval) {
      if (retval == -ENXIO) {
         userIf->port.jack.procEntry = NULL;

         kfree(userIf);
         return retval;
      }
   } else {
      userIf->port.jack.procEntry->read_proc = VNetUserIfProcRead;
      userIf->port.jack.procEntry->data = userIf;
   }

   /*
++ b/vmnet-only/vnetInt.h


void VNetSend(const VNetJack *jack, struct sk_buff *skb);

int VNetProc_MakeEntryOps(char *name, int mode,
                       VNetProcEntry **ret,
		       const struct file_operations *fops,
		       void *data);

void VNetProc_RemoveEntry(VNetProcEntry *node);

void VNetPrintJack(const VNetJack *jack, struct seq_file *seqf);

int VNet_MakeMACAddress(VNetPort *port);



Bool VNetCycleDetectIf(const char *name, int generation);

void VNetPrintPort(const VNetPort *port, struct seq_file *seqf);

int VNetSnprintf(char *str, size_t size, const char *format, ...);

- 




   VMBlockSetProcEntryOwner(controlProcMountpoint);

   /* Create /proc/fs/vmblock/dev */
   controlProcEntry = proc_create(VMBLOCK_CONTROL_DEVNAME,
                                  VMBLOCK_CONTROL_MODE,
                                  controlProcDirEntry,
                                  &ControlFileOps);
   if (!controlProcEntry) {
      Warning("SetupProcDevice: could not create " VMBLOCK_DEVICE "\n");
      remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);

      return -EINVAL;
   }

   controlProcEntry->proc_fops = &ControlFileOps;
   return 0;
}


Return to bug 470896

Lines 208-216 Link Here

(-)a/vmblock-only/linux/control.c (-4 / +4 lines)
208	VMBlockSetProcEntryOwner(controlProcMountpoint);	208	VMBlockSetProcEntryOwner(controlProcMountpoint);
209		209
210	/* Create /proc/fs/vmblock/dev */	210	/* Create /proc/fs/vmblock/dev */
211	controlProcEntry = create_proc_entry(VMBLOCK_CONTROL_DEVNAME,	211	controlProcEntry = proc_create(VMBLOCK_CONTROL_DEVNAME,
212	VMBLOCK_CONTROL_MODE,	212	VMBLOCK_CONTROL_MODE,
213	controlProcDirEntry);	213	controlProcDirEntry,
		214	&ControlFileOps);
214	if (!controlProcEntry) {	215	if (!controlProcEntry) {
215	Warning("SetupProcDevice: could not create " VMBLOCK_DEVICE "\n");	216	Warning("SetupProcDevice: could not create " VMBLOCK_DEVICE "\n");
216	remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);	217	remove_proc_entry(VMBLOCK_CONTROL_MOUNTPOINT, controlProcDirEntry);
Lines 218-224 Link Here
218	return -EINVAL;	219	return -EINVAL;
219	}	220	}
220		221
221	controlProcEntry->proc_fops = &ControlFileOps;
222	return 0;	222	return 0;
223	}	223	}
224		224