Changeset 11945


Ignore:
Timestamp:
2008-07-26T21:17:07+02:00 (10 years ago)
Author:
juhosg
Message:

[kernel] cleanup trailing whitespaces in 2.6.26 patches

Location:
trunk/target/linux/generic-2.6/patches-2.6.26
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic-2.6/patches-2.6.26/060-block2mtd_init.patch

    r11323 r11945  
    3636        if (!dev->mtd.name) 
    3737                goto devinit_err; 
    38 +        
     38  
     39-       sprintf(dev->mtd.name, "block2mtd: %s", devname); 
    3940+       strcpy(dev->mtd.name, mtdname); 
    4041  
    41 -       sprintf(dev->mtd.name, "block2mtd: %s", devname); 
    42 - 
    4342-       dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK; 
    4443+       dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK & ~(erase_size - 1); 
     
    4645        dev->mtd.writesize = 1; 
    4746        dev->mtd.type = MTD_RAM; 
    48 @@ -298,15 +304,18 @@ 
    49         dev->mtd.read = block2mtd_read; 
     47@@ -299,14 +305,17 @@ 
    5048        dev->mtd.priv = dev; 
    5149        dev->mtd.owner = THIS_MODULE; 
    52 - 
     50  
    5351-       if (add_mtd_device(&dev->mtd)) { 
    54 +        
    5552+       part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL); 
    5653+       part->name = dev->mtd.name; 
  • trunk/target/linux/generic-2.6/patches-2.6.26/065-rootfs_split.patch

    r11336 r11945  
    867867        dev->mtd.owner = THIS_MODULE; 
    868868+       dev->mtd.refresh_device = block2mtd_refresh; 
    869          
     869  
    870870        part = kzalloc(sizeof(struct mtd_partition), GFP_KERNEL); 
    871871        part->name = dev->mtd.name; 
  • trunk/target/linux/generic-2.6/patches-2.6.26/100-netfilter_layer7_2.17.patch

    r11569 r11945  
    171171+/* Use instead of regcomp.  As we expect to be seeing the same regexps over and 
    172172+over again, it make sense to cache the results. */ 
    173 +static regexp * compile_and_cache(const char * regex_string,  
     173+static regexp * compile_and_cache(const char * regex_string, 
    174174+                                  const char * protocol) 
    175175+{ 
     
    228228+               if (net_ratelimit()) 
    229229+                       printk(KERN_ERR "layer7: Error compiling regexp " 
    230 +                                       "\"%s\" (%s)\n",  
     230+                                       "\"%s\" (%s)\n", 
    231231+                                       regex_string, protocol); 
    232232+               /* pattern is now cached as NULL, so we won't try again. */ 
     
    276276+ 
    277277+/* handles whether there's a match when we aren't appending data anymore */ 
    278 +static int match_no_append(struct nf_conn * conntrack,  
    279 +                           struct nf_conn * master_conntrack,  
     278+static int match_no_append(struct nf_conn * conntrack, 
     279+                           struct nf_conn * master_conntrack, 
    280280+                           enum ip_conntrack_info ctinfo, 
    281281+                           enum ip_conntrack_info master_ctinfo, 
     
    287287+       #ifdef CONFIG_IP_NF_MATCH_LAYER7_DEBUG 
    288288+               if(!master_conntrack->layer7.app_proto) { 
    289 +                       char * f =  
     289+                       char * f = 
    290290+                         friendly_print(master_conntrack->layer7.app_data); 
    291 +                       char * g =  
     291+                       char * g = 
    292292+                         hex_print(master_conntrack->layer7.app_data); 
    293293+                       DPRINTK("\nl7-filter gave up after %d bytes " 
     
    307307+               /* Here child connections set their .app_proto (for /proc) */ 
    308308+               if(!conntrack->layer7.app_proto) { 
    309 +                       conntrack->layer7.app_proto =  
    310 +                         kmalloc(strlen(master_conntrack->layer7.app_proto)+1,  
     309+                       conntrack->layer7.app_proto = 
     310+                         kmalloc(strlen(master_conntrack->layer7.app_proto)+1, 
    311311+                           GFP_ATOMIC); 
    312312+                       if(!conntrack->layer7.app_proto){ 
     
    317317+                               return 1; 
    318318+                       } 
    319 +                       strcpy(conntrack->layer7.app_proto,  
     319+                       strcpy(conntrack->layer7.app_proto, 
    320320+                               master_conntrack->layer7.app_proto); 
    321321+               } 
    322322+ 
    323 +               return (!strcmp(master_conntrack->layer7.app_proto,  
     323+               return (!strcmp(master_conntrack->layer7.app_proto, 
    324324+                               info->protocol)); 
    325325+       } 
     
    327327+               /* If not classified, set to "unknown" to distinguish from 
    328328+               connections that are still being tested. */ 
    329 +               master_conntrack->layer7.app_proto =  
     329+               master_conntrack->layer7.app_proto = 
    330330+                       kmalloc(strlen("unknown")+1, GFP_ATOMIC); 
    331331+               if(!master_conntrack->layer7.app_proto){ 
     
    347347+       int oldlength = master_conntrack->layer7.app_data_len; 
    348348+ 
    349 +       /* This is a fix for a race condition by Deti Fliegl. However, I'm not  
    350 +          clear on whether the race condition exists or whether this really  
    351 +          fixes it.  I might just be being dense... Anyway, if it's not really  
     349+       /* This is a fix for a race condition by Deti Fliegl. However, I'm not 
     350+          clear on whether the race condition exists or whether this really 
     351+          fixes it.  I might just be being dense... Anyway, if it's not really 
    352352+          a fix, all it does is waste a very small amount of time. */ 
    353353+       if(!master_conntrack->layer7.app_data) return 0; 
     
    360360+                       /* the kernel version of tolower mungs 'upper ascii' */ 
    361361+                       master_conntrack->layer7.app_data[length+oldlength] = 
    362 +                               isascii(app_data[i])?  
     362+                               isascii(app_data[i])? 
    363363+                                       tolower(app_data[i]) : app_data[i]; 
    364364+                       length++; 
     
    450450+{ 
    451451+       /* sidestep const without getting a compiler warning... */ 
    452 +       struct sk_buff * skb = (struct sk_buff *)skbin;  
     452+       struct sk_buff * skb = (struct sk_buff *)skbin; 
    453453+ 
    454454+       const struct xt_layer7_info * info = matchinfo; 
     
    486486+          master_conntrack->layer7.app_proto) { 
    487487+ 
    488 +               pattern_result = match_no_append(conntrack, master_conntrack,  
     488+               pattern_result = match_no_append(conntrack, master_conntrack, 
    489489+                                                ctinfo, master_ctinfo, info); 
    490490+ 
    491 +               /* skb->cb[0] == seen. Don't do things twice if there are  
    492 +               multiple l7 rules. I'm not sure that using cb for this purpose  
    493 +               is correct, even though it says "put your private variables  
     491+               /* skb->cb[0] == seen. Don't do things twice if there are 
     492+               multiple l7 rules. I'm not sure that using cb for this purpose 
     493+               is correct, even though it says "put your private variables 
    494494+               there". But it doesn't look like it is being used for anything 
    495495+               else in the skbs that make it here. */ 
     
    518518+ 
    519519+       /* On the first packet of a connection, allocate space for app data */ 
    520 +       if(TOTAL_PACKETS == 1 && !skb->cb[0] &&  
     520+       if(TOTAL_PACKETS == 1 && !skb->cb[0] && 
    521521+          !master_conntrack->layer7.app_data){ 
    522 +               master_conntrack->layer7.app_data =  
     522+               master_conntrack->layer7.app_data = 
    523523+                       kmalloc(maxdatalen, GFP_ATOMIC); 
    524524+               if(!master_conntrack->layer7.app_data){ 
     
    563563+                       "(%d/%d packets)\n", TOTAL_PACKETS, num_packets); 
    564564+       /* If the regexp failed to compile, don't bother running it */ 
    565 +       } else if(comppattern &&  
     565+       } else if(comppattern && 
    566566+                 regexec(comppattern, master_conntrack->layer7.app_data)){ 
    567567+               DPRINTK("layer7: matched %s\n", info->protocol); 
     
    570570+ 
    571571+       if(pattern_result == 1) { 
    572 +               master_conntrack->layer7.app_proto =  
     572+               master_conntrack->layer7.app_proto = 
    573573+                       kmalloc(strlen(info->protocol)+1, GFP_ATOMIC); 
    574574+               if(!master_conntrack->layer7.app_proto){ 
     
    915915+       int flags; 
    916916+       struct match_globals g; 
    917 +        
     917+ 
    918918+       /* commented out by ethan 
    919919+          extern char *malloc(); 
     
    10421042+ 
    10431043+       /* Make a closing node, and hook it on the end. */ 
    1044 +       ender = regnode(g, (paren) ? CLOSE+parno : END);         
     1044+       ender = regnode(g, (paren) ? CLOSE+parno : END); 
    10451045+       regtail(g, ret, ender); 
    10461046+ 
     
    19871987+       register int no; 
    19881988+       register int len; 
    1989 +        
     1989+ 
    19901990+       /* Not necessary and gcc doesn't like it -MLS */ 
    19911991+       /*extern char *strncpy();*/ 
  • trunk/target/linux/generic-2.6/patches-2.6.26/101-netfilter_layer7_pktmatch.patch

    r11296 r11945  
    2121        int length = 0, i; 
    2222-       int oldlength = master_conntrack->layer7.app_data_len; 
    23 - 
    24 -       /* This is a fix for a race condition by Deti Fliegl. However, I'm not  
    25 -          clear on whether the race condition exists or whether this really  
    26 -          fixes it.  I might just be being dense... Anyway, if it's not really  
     23  
     24-       /* This is a fix for a race condition by Deti Fliegl. However, I'm not 
     25-          clear on whether the race condition exists or whether this really 
     26-          fixes it.  I might just be being dense... Anyway, if it's not really 
    2727-          a fix, all it does is waste a very small amount of time. */ 
    2828-       if(!master_conntrack->layer7.app_data) return 0; 
    29 +        
    3029+       if (!target) return 0; 
    3130  
     
    3938-                       master_conntrack->layer7.app_data[length+oldlength] = 
    4039+                       target[length+offset] = 
    41                                 isascii(app_data[i])?  
     40                                isascii(app_data[i])? 
    4241                                        tolower(app_data[i]) : app_data[i]; 
    4342                        length++; 
     
    4544        } 
    4645+       target[length+offset] = '\0'; 
    47 +        
     46+ 
    4847+       return length; 
    4948+} 
     
    8079+          master_conntrack->layer7.app_proto)) { 
    8180  
    82                 pattern_result = match_no_append(conntrack, master_conntrack,  
     81                pattern_result = match_no_append(conntrack, master_conntrack, 
    8382                                                 ctinfo, master_ctinfo, info); 
    8483@@ -473,6 +475,25 @@ 
     
    106105+ 
    107106        /* On the first packet of a connection, allocate space for app data */ 
    108         if(TOTAL_PACKETS == 1 && !skb->cb[0] &&  
     107        if(TOTAL_PACKETS == 1 && !skb->cb[0] && 
    109108           !master_conntrack->layer7.app_data){ 
  • trunk/target/linux/generic-2.6/patches-2.6.26/130-netfilter_ipset.patch

    r11336 r11945  
    1212+ * This program is free software; you can redistribute it and/or modify 
    1313+ * it under the terms of the GNU General Public License version 2 as 
    14 + * published by the Free Software Foundation.   
     14+ * published by the Free Software Foundation. 
    1515+ */ 
    1616+ 
     
    4141+ */ 
    4242+ 
    43 +/*  
    44 + * Used so that the kernel module and ipset-binary can match their versions  
     43+/* 
     44+ * Used so that the kernel module and ipset-binary can match their versions 
    4545+ */ 
    4646+#define IP_SET_PROTOCOL_VERSION 2 
     
    5353+ * The representation works in HOST byte order, because most set types 
    5454+ * will perform arithmetic operations and compare operations. 
    55 + *  
     55+ * 
    5656+ * For now the type is an uint32_t. 
    5757+ * 
     
    104104+ */ 
    105105+ 
    106 +/* Single shot operations:  
    107 + * version, create, destroy, flush, rename and swap  
     106+/* Single shot operations: 
     107+ * version, create, destroy, flush, rename and swap 
    108108+ * 
    109109+ * Sets are identified by name. 
     
    156156+}; 
    157157+ 
    158 +/* Double shots operations:  
     158+/* Double shots operations: 
    159159+ * add, del, test, bind and unbind. 
    160160+ * 
     
    198198+ 
    199199+#define IP_SET_OP_UNBIND_SET   0x00000105      /* Unbind an IP from a set */ 
    200 +/* Uses ip_set_req_bind, with type speficic addage  
     200+/* Uses ip_set_req_bind, with type speficic addage 
    201201+ * index = 0 means unbinding for all sets */ 
    202202+ 
     
    244244+struct ip_set_req_list { 
    245245+       IP_SET_REQ_BYINDEX; 
    246 +       /* sets number of struct ip_set_list in reply */  
     246+       /* sets number of struct ip_set_list in reply */ 
    247247+}; 
    248248+ 
     
    284284+#define IP_SET_OP_RESTORE      0x00000205 
    285285+/* Uses ip_set_req_setnames followed by ip_set_restore structures 
    286 + * plus a marker ip_set_restore, followed by ip_set_hash_save  
     286+ * plus a marker ip_set_restore, followed by ip_set_hash_save 
    287287+ * structures. 
    288288+ */ 
     
    345345+        */ 
    346346+       int (*testip_kernel) (struct ip_set *set, 
    347 +                             const struct sk_buff * skb,  
     347+                             const struct sk_buff * skb, 
    348348+                             ip_set_ip_t *ip, 
    349349+                             const u_int32_t *flags, 
     
    368368+        * If the address was not already in the set, 0 is returned. 
    369369+        */ 
    370 +       int (*addip) (struct ip_set *set,  
     370+       int (*addip) (struct ip_set *set, 
    371371+                     const void *data, size_t size, 
    372372+                     ip_set_ip_t *ip); 
     
    378378+        */ 
    379379+       int (*addip_kernel) (struct ip_set *set, 
    380 +                            const struct sk_buff * skb,  
     380+                            const struct sk_buff * skb, 
    381381+                            ip_set_ip_t *ip, 
    382382+                            const u_int32_t *flags, 
     
    388388+        * If the address really was in the set, 0 is returned. 
    389389+        */ 
    390 +       int (*delip) (struct ip_set *set,  
     390+       int (*delip) (struct ip_set *set, 
    391391+                     const void *data, size_t size, 
    392392+                     ip_set_ip_t *ip); 
     
    398398+        */ 
    399399+       int (*delip_kernel) (struct ip_set *set, 
    400 +                            const struct sk_buff * skb,  
     400+                            const struct sk_buff * skb, 
    401401+                            ip_set_ip_t *ip, 
    402402+                            const u_int32_t *flags, 
     
    430430+        * 
    431431+        * Fill in the information in "data". 
    432 +        * This function is always run after list_header_size() under a  
    433 +        * writelock on the set. Therefor is the length of "data" always  
    434 +        * correct.  
     432+        * This function is always run after list_header_size() under a 
     433+        * writelock on the set. Therefor is the length of "data" always 
     434+        * correct. 
    435435+        */ 
    436 +       void (*list_header) (const struct ip_set *set,  
     436+       void (*list_header) (const struct ip_set *set, 
    437437+                            void *data); 
    438438+ 
     
    444444+        * 
    445445+        * Fill in the information in "data". 
    446 +        * This function is always run after list_member_size() under a  
    447 +        * writelock on the set. Therefor is the length of "data" always  
    448 +        * correct.  
     446+        * This function is always run after list_member_size() under a 
     447+        * writelock on the set. Therefor is the length of "data" always 
     448+        * correct. 
    449449+        */ 
    450450+       void (*list_members) (const struct ip_set *set, 
     
    568568+       unsigned int bits = 32; 
    569569+       ip_set_ip_t maskaddr; 
    570 +        
     570+ 
    571571+       if (mask == 0xFFFFFFFF) 
    572572+               return bits; 
    573 +        
     573+ 
    574574+       maskaddr = 0xFFFFFFFE; 
    575575+       while (--bits >= 0 && maskaddr != mask) 
    576576+               maskaddr <<= 1; 
    577 +        
     577+ 
    578578+       return bits; 
    579579+} 
     
    583583+{ 
    584584+       ip_set_ip_t mask = 0xFFFFFFFE; 
    585 +        
     585+ 
    586586+       *bits = 32; 
    587587+       while (--(*bits) >= 0 && mask && (to & mask) != from) 
    588588+               mask <<= 1; 
    589 +                
     589+ 
    590590+       return mask; 
    591591+} 
    592 +        
     592+ 
    593593+#endif /* __IP_SET_IPMAP_H */ 
    594594--- /dev/null 
     
    946946+}; 
    947947+ 
    948 +static inline void *  
     948+static inline void * 
    949949+harray_malloc(size_t hashsize, size_t typesize, int flags) 
    950950+{ 
     
    962962+       if (hashsize % max_elements) 
    963963+               size++; 
    964 +        
     964+ 
    965965+       /* Last pointer signals end of arrays */ 
    966966+       harray = kmalloc(sizeof(struct harray) + (size + 1) * sizeof(void *), 
     
    969969+       if (!harray) 
    970970+               return NULL; 
    971 +        
     971+ 
    972972+       for (i = 0; i < size - 1; i++) { 
    973973+               harray->arrays[i] = kmalloc(max_elements * typesize, flags); 
     
    976976+               memset(harray->arrays[i], 0, max_elements * typesize); 
    977977+       } 
    978 +       harray->arrays[i] = kmalloc((hashsize - i * max_elements) * typesize,  
     978+       harray->arrays[i] = kmalloc((hashsize - i * max_elements) * typesize, 
    979979+                                   flags); 
    980980+       if (!harray->arrays[i]) 
     
    984984+       harray->max_elements = max_elements; 
    985985+       harray->arrays[size] = NULL; 
    986 +        
     986+ 
    987987+       return (void *)harray; 
    988988+ 
     
    999999+       struct harray *harray = (struct harray *) h; 
    10001000+       size_t i; 
    1001 +        
     1001+ 
    10021002+       for (i = 0; harray->arrays[i] != NULL; i++) 
    10031003+               kfree(harray->arrays[i]); 
     
    10091009+       struct harray *harray = (struct harray *) h; 
    10101010+       size_t i; 
    1011 +        
     1011+ 
    10121012+       for (i = 0; harray->arrays[i+1] != NULL; i++) 
    10131013+               memset(harray->arrays[i], 0, harray->max_elements * typesize); 
    1014 +       memset(harray->arrays[i], 0,  
     1014+       memset(harray->arrays[i], 0, 
    10151015+              (hashsize - i * harray->max_elements) * typesize); 
    10161016+} 
     
    10601060+static unsigned char shifts[] = {255, 253, 249, 241, 225, 193, 129, 1}; 
    10611061+ 
    1062 +static inline ip_set_ip_t  
     1062+static inline ip_set_ip_t 
    10631063+pack(ip_set_ip_t ip, unsigned char cidr) 
    10641064+{ 
     
    10711071+#endif 
    10721072+       n = cidr / 8; 
    1073 +       t = cidr % 8;    
     1073+       t = cidr % 8; 
    10741074+       a = &((unsigned char *)paddr)[n]; 
    10751075+       *a = *a /(1 << (8 - t)) + shifts[t]; 
     
    11451145+ * This program is free software; you can redistribute it and/or modify 
    11461146+ * it under the terms of the GNU General Public License version 2 as 
    1147 + * published by the Free Software Foundation.   
     1147+ * published by the Free Software Foundation. 
    11481148+ */ 
    11491149+ 
     
    11841184+/* 
    11851185+ * Sets are identified either by the index in ip_set_list or by id. 
    1186 + * The id never changes and is used to find a key in the hash.  
    1187 + * The index may change by swapping and used at all other places  
     1186+ * The id never changes and is used to find a key in the hash. 
     1187+ * The index may change by swapping and used at all other places 
    11881188+ * (set/SET netfilter modules, binding value, etc.) 
    11891189+ * 
    11901190+ * Userspace requests are serialized by ip_set_mutex and sets can 
    1191 + * be deleted only from userspace. Therefore ip_set_list locking  
     1191+ * be deleted only from userspace. Therefore ip_set_list locking 
    11921192+ * must obey the following rules: 
    11931193+ * 
     
    12201220+               if (set_hash->id == id && set_hash->ip == ip) 
    12211221+                       return set_hash; 
    1222 +                        
     1222+ 
    12231223+       return NULL; 
    12241224+} 
     
    12271227+ip_set_find_in_hash(ip_set_id_t id, ip_set_ip_t ip) 
    12281228+{ 
    1229 +       u_int32_t key = jhash_2words(id, ip, ip_set_hash_random)  
     1229+       u_int32_t key = jhash_2words(id, ip, ip_set_hash_random) 
    12301230+                               % ip_set_bindings_hash_size; 
    12311231+       struct ip_set_hash *set_hash; 
     
    12331233+       ASSERT_READ_LOCK(&ip_set_lock); 
    12341234+       IP_SET_ASSERT(ip_set_list[id]); 
    1235 +       DP("set: %s, ip: %u.%u.%u.%u", ip_set_list[id]->name, HIPQUAD(ip));      
    1236 +        
     1235+       DP("set: %s, ip: %u.%u.%u.%u", ip_set_list[id]->name, HIPQUAD(ip)); 
     1236+ 
    12371237+       set_hash = __ip_set_find(key, id, ip); 
    1238 +        
    1239 +       DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name,  
     1238+ 
     1239+       DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name, 
    12401240+          HIPQUAD(ip), 
    12411241+          set_hash != NULL ? ip_set_list[set_hash->binding]->name : ""); 
     
    12441244+} 
    12451245+ 
    1246 +static inline void  
     1246+static inline void 
    12471247+__set_hash_del(struct ip_set_hash *set_hash) 
    12481248+{ 
    12491249+       ASSERT_WRITE_LOCK(&ip_set_lock); 
    1250 +       IP_SET_ASSERT(ip_set_list[set_hash->binding]);   
     1250+       IP_SET_ASSERT(ip_set_list[set_hash->binding]); 
    12511251+ 
    12521252+       __ip_set_put(set_hash->binding); 
     
    12611261+                               % ip_set_bindings_hash_size; 
    12621262+       struct ip_set_hash *set_hash; 
    1263 +        
     1263+ 
    12641264+       IP_SET_ASSERT(ip_set_list[id]); 
    1265 +       DP("set: %s, ip: %u.%u.%u.%u", ip_set_list[id]->name, HIPQUAD(ip));      
     1265+       DP("set: %s, ip: %u.%u.%u.%u", ip_set_list[id]->name, HIPQUAD(ip)); 
    12661266+       write_lock_bh(&ip_set_lock); 
    12671267+       set_hash = __ip_set_find(key, id, ip); 
     
    12761276+} 
    12771277+ 
    1278 +static int  
     1278+static int 
    12791279+ip_set_hash_add(ip_set_id_t id, ip_set_ip_t ip, ip_set_id_t binding) 
    12801280+{ 
     
    12831283+       struct ip_set_hash *set_hash; 
    12841284+       int ret = 0; 
    1285 +        
     1285+ 
    12861286+       IP_SET_ASSERT(ip_set_list[id]); 
    12871287+       IP_SET_ASSERT(ip_set_list[binding]); 
    1288 +       DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name,  
     1288+       DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name, 
    12891289+          HIPQUAD(ip), ip_set_list[binding]->name); 
    12901290+       write_lock_bh(&ip_set_lock); 
     
    13011301+               list_add(&set_hash->list, &ip_set_hash[key]); 
    13021302+       } else { 
    1303 +               IP_SET_ASSERT(ip_set_list[set_hash->binding]);   
     1303+               IP_SET_ASSERT(ip_set_list[set_hash->binding]); 
    13041304+               DP("overwrite binding: %s", 
    13051305+                  ip_set_list[set_hash->binding]->name); 
     
    13541354+       int res; 
    13551355+       unsigned char i = 0; 
    1356 +        
     1356+ 
    13571357+       IP_SET_ASSERT(flags[i]); 
    13581358+       read_lock_bh(&ip_set_lock); 
     
    13651365+               read_unlock_bh(&set->lock); 
    13661366+               i += !!(set->type->features & IPSET_DATA_DOUBLE); 
    1367 +       } while (res > 0  
    1368 +                && flags[i]  
     1367+       } while (res > 0 
     1368+                && flags[i] 
    13691369+                && follow_bindings(index, set, ip)); 
    13701370+       read_unlock_bh(&ip_set_lock); 
     
    13951395+               i += !!(set->type->features & IPSET_DATA_DOUBLE); 
    13961396+       } while ((res == 0 || res == -EEXIST) 
    1397 +                && flags[i]  
     1397+                && flags[i] 
    13981398+                && follow_bindings(index, set, ip)); 
    13991399+       read_unlock_bh(&ip_set_lock); 
     
    14261426+               i += !!(set->type->features & IPSET_DATA_DOUBLE); 
    14271427+       } while ((res == 0 || res == -EEXIST) 
    1428 +                && flags[i]  
     1428+                && flags[i] 
    14291429+                && follow_bindings(index, set, ip)); 
    14301430+       read_unlock_bh(&ip_set_lock); 
     
    14441444+} 
    14451445+ 
    1446 +int  
     1446+int 
    14471447+ip_set_register_set_type(struct ip_set_type *set_type) 
    14481448+{ 
    14491449+       int ret = 0; 
    1450 +        
     1450+ 
    14511451+       if (set_type->protocol_version != IP_SET_PROTOCOL_VERSION) { 
    14521452+               ip_set_printk("'%s' uses wrong protocol version %u (want %u)", 
     
    14601460+       if (find_set_type(set_type->typename)) { 
    14611461+               /* Duplicate! */ 
    1462 +               ip_set_printk("'%s' already registered!",  
     1462+               ip_set_printk("'%s' already registered!", 
    14631463+                             set_type->typename); 
    14641464+               ret = -EINVAL; 
     
    15061506+{ 
    15071507+       ip_set_id_t i, index = IP_SET_INVALID_ID; 
    1508 +        
     1508+ 
    15091509+       down(&ip_set_app_mutex); 
    15101510+       for (i = 0; i < ip_set_max; i++) { 
     
    15321532+       if (index >= ip_set_max) 
    15331533+               return IP_SET_INVALID_ID; 
    1534 +        
     1534+ 
    15351535+       if (ip_set_list[index]) 
    15361536+               __ip_set_get(index); 
    15371537+       else 
    15381538+               index = IP_SET_INVALID_ID; 
    1539 +                
     1539+ 
    15401540+       up(&ip_set_app_mutex); 
    15411541+       return index; 
     
    15601560+{ 
    15611561+       ip_set_id_t i, index = IP_SET_INVALID_ID; 
    1562 +        
     1562+ 
    15631563+       for (i = 0; i < ip_set_max; i++) { 
    15641564+               if (ip_set_list[i] != NULL 
     
    15761576+       if (index >= ip_set_max || ip_set_list[index] == NULL) 
    15771577+               index = IP_SET_INVALID_ID; 
    1578 +        
     1578+ 
    15791579+       return index; 
    15801580+} 
     
    16071607+       ip_set_ip_t ip; 
    16081608+       int res; 
    1609 +        
     1609+ 
    16101610+       IP_SET_ASSERT(set); 
    16111611+       do { 
     
    16391639+       ip_set_ip_t ip; 
    16401640+       int res; 
    1641 +        
     1641+ 
    16421642+       IP_SET_ASSERT(set); 
    16431643+       write_lock_bh(&set->lock); 
     
    16831683+       if (size < sizeof(struct ip_set_req_bind)) 
    16841684+               return -EINVAL; 
    1685 +                
     1685+ 
    16861686+       req_bind = (struct ip_set_req_bind *) data; 
    16871687+       req_bind->binding[IP_SET_MAXNAMELEN - 1] = '\0'; 
     
    16901690+               /* Default binding of a set */ 
    16911691+               char *binding_name; 
    1692 +                
     1692+ 
    16931693+               if (size != sizeof(struct ip_set_req_bind) + IP_SET_MAXNAMELEN) 
    16941694+                       return -EINVAL; 
    16951695+ 
    1696 +               binding_name = (char *)(data + sizeof(struct ip_set_req_bind));  
     1696+               binding_name = (char *)(data + sizeof(struct ip_set_req_bind)); 
    16971697+               binding_name[IP_SET_MAXNAMELEN - 1] = '\0'; 
    16981698+ 
     
    17211721+       DP("set %s, ip: %u.%u.%u.%u, binding %s", 
    17221722+          set->name, HIPQUAD(ip), ip_set_list[binding]->name); 
    1723 +        
     1723+ 
    17241724+       if (res >= 0) 
    17251725+               res = ip_set_hash_add(set->id, ip, binding); 
     
    17701770+       if (size < sizeof(struct ip_set_req_bind)) 
    17711771+               return -EINVAL; 
    1772 +                
     1772+ 
    17731773+       req_bind = (struct ip_set_req_bind *) data; 
    17741774+       req_bind->binding[IP_SET_MAXNAMELEN - 1] = '\0'; 
    1775 +        
     1775+ 
    17761776+       DP("%u %s", index, req_bind->binding); 
    17771777+       if (index == IP_SET_INVALID_ID) { 
     
    17931793+               return -EINVAL; 
    17941794+       } 
    1795 +        
     1795+ 
    17961796+       set = ip_set_list[index]; 
    17971797+       IP_SET_ASSERT(set); 
     
    18021802+               if (binding == IP_SET_INVALID_ID) 
    18031803+                       return -ENOENT; 
    1804 +                        
     1804+ 
    18051805+               write_lock_bh(&ip_set_lock); 
    18061806+               /* Sets in hash values are referenced */ 
     
    18181818+               return 0; 
    18191819+       } 
    1820 +        
     1820+ 
    18211821+       res = __ip_set_testip(set, 
    18221822+                             data + sizeof(struct ip_set_req_bind), 
     
    18451845+       if (size < sizeof(struct ip_set_req_bind)) 
    18461846+               return -EINVAL; 
    1847 +                
     1847+ 
    18481848+       req_bind = (struct ip_set_req_bind *) data; 
    18491849+       req_bind->binding[IP_SET_MAXNAMELEN - 1] = '\0'; 
     
    18521852+               /* Default binding of set */ 
    18531853+               char *binding_name; 
    1854 +                
     1854+ 
    18551855+               if (size != sizeof(struct ip_set_req_bind) + IP_SET_MAXNAMELEN) 
    18561856+                       return -EINVAL; 
    18571857+ 
    1858 +               binding_name = (char *)(data + sizeof(struct ip_set_req_bind));  
     1858+               binding_name = (char *)(data + sizeof(struct ip_set_req_bind)); 
    18591859+               binding_name[IP_SET_MAXNAMELEN - 1] = '\0'; 
    18601860+ 
     
    18621862+               if (binding == IP_SET_INVALID_ID) 
    18631863+                       return -ENOENT; 
    1864 +                
     1864+ 
    18651865+               res = (set->binding == binding) ? -EEXIST : 0; 
    18661866+ 
     
    18701870+       if (binding == IP_SET_INVALID_ID) 
    18711871+               return -ENOENT; 
    1872 +                
    1873 +        
     1872+ 
     1873+ 
    18741874+       res = __ip_set_testip(set, 
    18751875+                             data + sizeof(struct ip_set_req_bind), 
     
    18781878+       DP("set %s, ip: %u.%u.%u.%u, binding %s", 
    18791879+          set->name, HIPQUAD(ip), ip_set_list[binding]->name); 
    1880 +           
     1880+ 
    18811881+       if (res >= 0) 
    18821882+               res = (ip_set_find_in_hash(set->id, ip) == binding) 
     
    18901890+{ 
    18911891+       struct ip_set_type *type; 
    1892 +        
     1892+ 
    18931893+       read_lock_bh(&ip_set_lock); 
    18941894+       type = find_set_type(typename); 
     
    19191919+               return -ERANGE; 
    19201920+       /* Check that index is usable as id (swapping) */ 
    1921 +    check:      
     1921+    check: 
    19221922+       for (i = 0;  i < ip_set_max; i++) { 
    19231923+               if (ip_set_list[i] != NULL 
     
    19991999+       /* 
    20002000+        * Here, we have a valid, constructed set. &ip_set_lock again, 
    2001 +        * find free id/index and check that it is not already in  
     2001+        * find free id/index and check that it is not already in 
    20022002+        * ip_set_list. 
    20032003+        */ 
     
    20142014+               goto cleanup; 
    20152015+       } 
    2016 +         
     2016+ 
    20172017+       /* 
    20182018+        * Finally! Add our shiny new set to the list, and be done. 
     
    20232023+       write_unlock_bh(&ip_set_lock); 
    20242024+       return res; 
    2025 +        
     2025+ 
    20262026+    cleanup: 
    20272027+       write_unlock_bh(&ip_set_lock); 
     
    20732073+       } else { 
    20742074+               for (i = 0; i < ip_set_max; i++) { 
    2075 +                       if (ip_set_list[i] != NULL  
     2075+                       if (ip_set_list[i] != NULL 
    20762076+                           && (atomic_read(&ip_set_list[i]->ref))) 
    20772077+                               return -EBUSY; 
     
    20962096+} 
    20972097+ 
    2098 +/*  
     2098+/* 
    20992099+ * Flush data in a set - or in all sets 
    21002100+ */ 
     
    21232123+       for (i = 0; i < ip_set_max; i++) { 
    21242124+               if (ip_set_list[i] != NULL 
    2125 +                   && strncmp(ip_set_list[i]->name,  
     2125+                   && strncmp(ip_set_list[i]->name, 
    21262126+                              name, 
    21272127+                              IP_SET_MAXNAMELEN - 1) == 0) { 
     
    21532153+               return -ENOEXEC; 
    21542154+ 
    2155 +       /* No magic here: ref munging protected by the mutex */  
     2155+       /* No magic here: ref munging protected by the mutex */ 
    21562156+       write_lock_bh(&ip_set_lock); 
    21572157+       strncpy(from_name, from->name, IP_SET_MAXNAMELEN); 
     
    21622162+       strncpy(to->name, from_name, IP_SET_MAXNAMELEN); 
    21632163+       atomic_set(&to->ref, from_ref); 
    2164 +        
     2164+ 
    21652165+       ip_set_list[from_index] = to; 
    21662166+       ip_set_list[to_index] = from; 
    2167 +        
     2167+ 
    21682168+       write_unlock_bh(&ip_set_lock); 
    21692169+       return 0; 
     
    21952195+{ 
    21962196+       if (set_hash->id == id) { 
    2197 +               struct ip_set_hash_list *hash_list =  
     2197+               struct ip_set_hash_list *hash_list = 
    21982198+                       (struct ip_set_hash_list *)(data + *used); 
    21992199+ 
     
    22582258+       /* Fill in set spefific bindings data */ 
    22592259+       FOREACH_HASH_DO(__set_hash_bindings, set->id, data, used); 
    2260 +        
     2260+ 
    22612261+       return 0; 
    22622262+ 
     
    22882288+ 
    22892289+       set = ip_set_list[index]; 
    2290 +       DP("set: %s, used: %u(%u) %p %p", set->name, *used, len,  
     2290+       DP("set: %s, used: %u(%u) %p %p", set->name, *used, len, 
    22912291+          data, data + *used); 
    22922292+ 
     
    23372337+       if (*res == 0 
    23382338+           && (id == IP_SET_INVALID_ID || set_hash->id == id)) { 
    2339 +               struct ip_set_hash_save *hash_save =  
     2339+               struct ip_set_hash_save *hash_save = 
    23402340+                       (struct ip_set_hash_save *)(data + *used); 
    23412341+               /* Ensure bindings size */ 
     
    23782378+       FOREACH_HASH_DO(__set_hash_save_bindings, index, data, used, len, &res); 
    23792379+ 
    2380 +       return res;      
     2380+       return res; 
    23812381+} 
    23822382+ 
     
    23972397+       while (1) { 
    23982398+               line++; 
    2399 +                
     2399+ 
    24002400+               DP("%u %u %u", used, sizeof(struct ip_set_restore), len); 
    24012401+               /* Get and ensure header size */ 
     
    24062406+ 
    24072407+               /* Ensure data size */ 
    2408 +               if (used  
    2409 +                   + set_restore->header_size  
     2408+               if (used 
     2409+                   + set_restore->header_size 
    24102410+                   + set_restore->members_size > len) 
    24112411+                       return line; 
     
    24162416+                       goto bindings; 
    24172417+               } 
    2418 +                
     2418+ 
    24192419+               /* Try to create the set */ 
    24202420+               DP("restore %s %s", set_restore->name, set_restore->typename); 
     
    24242424+                                   data + used, 
    24252425+                                   set_restore->header_size); 
    2426 +                
     2426+ 
    24272427+               if (res != 0) 
    24282428+                       return line; 
     
    24452445+                                          data + used + members_size, 
    24462446+                                          set->type->reqsize); 
    2447 +                       if (!(res == 0 || res == -EEXIST))  
     2447+                       if (!(res == 0 || res == -EEXIST)) 
    24482448+                               return line; 
    24492449+                       members_size += set->type->reqsize; 
     
    24542454+               if (members_size != set_restore->members_size) 
    24552455+                       return line++; 
    2456 +               used += set_restore->members_size;               
    2457 +       } 
    2458 +        
     2456+               used += set_restore->members_size; 
     2457+       } 
     2458+ 
    24592459+   bindings: 
    24602460+       /* Loop to restore bindings */ 
     
    24622462+               line++; 
    24632463+ 
    2464 +               DP("restore binding, line %u", line);            
     2464+               DP("restore binding, line %u", line); 
    24652465+               /* Get and ensure size */ 
    24662466+               if (used + sizeof(struct ip_set_hash_save) > len) 
     
    24682468+               hash_save = (struct ip_set_hash_save *) (data + used); 
    24692469+               used += sizeof(struct ip_set_hash_save); 
    2470 +                
     2470+ 
    24712471+               /* hash_save->id is used to store the index */ 
    24722472+               index = ip_set_find_byindex(hash_save->id); 
    24732473+               DP("restore binding index %u, id %u, %u -> %u", 
    2474 +                  index, hash_save->id, hash_save->ip, hash_save->binding);             
     2474+                  index, hash_save->id, hash_save->ip, hash_save->binding); 
    24752475+               if (index != hash_save->id) 
    24762476+                       return line; 
     
    24822482+               /* Null valued IP means default binding */ 
    24832483+               if (hash_save->ip) 
    2484 +                       res = ip_set_hash_add(set->id,  
     2484+                       res = ip_set_hash_add(set->id, 
    24852485+                                             hash_save->ip, 
    24862486+                                             hash_save->binding); 
     
    24982498+       if (used != len) 
    24992499+               return line; 
    2500 +        
    2501 +       return 0;        
     2500+ 
     2501+       return 0; 
    25022502+} 
    25032503+ 
     
    25462546+       op = (unsigned *)data; 
    25472547+       DP("op=%x", *op); 
    2548 +        
     2548+ 
    25492549+       if (*op < IP_SET_OP_VERSION) { 
    25502550+               /* Check the version at the beginning of operations */ 
     
    25612561+               struct ip_set_req_create *req_create 
    25622562+                       = (struct ip_set_req_create *) data; 
    2563 +                
     2563+ 
    25642564+               if (len < sizeof(struct ip_set_req_create)) { 
    25652565+                       ip_set_printk("short CREATE data (want >=%zu, got %u)", 
     
    25802580+               struct ip_set_req_std *req_destroy 
    25812581+                       = (struct ip_set_req_std *) data; 
    2582 +                
     2582+ 
    25832583+               if (len != sizeof(struct ip_set_req_std)) { 
    25842584+                       ip_set_printk("invalid DESTROY data (want %zu, got %u)", 
     
    25992599+                       } 
    26002600+               } 
    2601 +                        
     2601+ 
    26022602+               res = ip_set_destroy(index); 
    26032603+               goto done; 
     
    26412641+               req_rename->name[IP_SET_MAXNAMELEN - 1] = '\0'; 
    26422642+               req_rename->typename[IP_SET_MAXNAMELEN - 1] = '\0'; 
    2643 +                        
     2643+ 
    26442644+               index = ip_set_find_byname(req_rename->name); 
    26452645+               if (index == IP_SET_INVALID_ID) { 
     
    26782678+               goto done; 
    26792679+       } 
    2680 +       default:  
     2680+       default: 
    26812681+               break;  /* Set identified by id */ 
    26822682+       } 
    2683 +        
     2683+ 
    26842684+       /* There we may have add/del/test/bind/unbind/test_bind operations */ 
    26852685+       if (*op < IP_SET_OP_ADD_IP || *op > IP_SET_OP_TEST_BIND_SET) { 
     
    26982698+ 
    26992699+       /* -U :all: :all:|:default: uses IP_SET_INVALID_ID */ 
    2700 +       if (!(*op == IP_SET_OP_UNBIND_SET  
     2700+       if (!(*op == IP_SET_OP_UNBIND_SET 
    27012701+             && req_adt->index == IP_SET_INVALID_ID)) { 
    27022702+               index = ip_set_find_byindex(req_adt->index); 
     
    27172717+} 
    27182718+ 
    2719 +static int  
     2719+static int 
    27202720+ip_set_sockfn_get(struct sock *sk, int optval, void *user, int *len) 
    27212721+{ 
     
    28522852+               } else { 
    28532853+                       req_max_sets->set.name[IP_SET_MAXNAMELEN - 1] = '\0'; 
    2854 +                       req_max_sets->set.index =  
     2854+                       req_max_sets->set.index = 
    28552855+                               ip_set_find_byname(req_max_sets->set.name); 
    28562856+                       if (req_max_sets->set.index == IP_SET_INVALID_ID) { 
     
    28672867+               goto copy; 
    28682868+       } 
    2869 +       case IP_SET_OP_LIST_SIZE:  
     2869+       case IP_SET_OP_LIST_SIZE: 
    28702870+       case IP_SET_OP_SAVE_SIZE: { 
    28712871+               struct ip_set_req_setnames *req_setnames 
     
    28882888+                       if (ip_set_list[i] == NULL) 
    28892889+                               continue; 
    2890 +                       name_list = (struct ip_set_name_list *)  
     2890+                       name_list = (struct ip_set_name_list *) 
    28912891+                               (data + used); 
    28922892+                       used += sizeof(struct ip_set_name_list); 
     
    29182918+                                       + set->type->list_members_size(set); 
    29192919+                               /* Sets are identified by id in the hash */ 
    2920 +                               FOREACH_HASH_DO(__set_hash_bindings_size_list,  
     2920+                               FOREACH_HASH_DO(__set_hash_bindings_size_list, 
    29212921+                                               set->id, &req_setnames->size); 
    29222922+                               break; 
     
    30083008+               if (res == 0) 
    30093009+                       res = ip_set_save_bindings(index, data, &used, *len); 
    3010 +                        
     3010+ 
    30113011+               if (res != 0) 
    30123012+                       goto done; 
     
    30513051+                    : ":all:", copylen); 
    30523052+       res = copy_to_user(user, data, copylen); 
    3053 +        
     3053+ 
    30543054+    done: 
    30553055+       up(&ip_set_app_mutex); 
     
    31493149+ * This program is free software; you can redistribute it and/or modify 
    31503150+ * it under the terms of the GNU General Public License version 2 as 
    3151 + * published by the Free Software Foundation.   
     3151+ * published by the Free Software Foundation. 
    31523152+ */ 
    31533153+ 
     
    31923192+       DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u, %u.%u.%u.%u", 
    31933193+          set->name, HIPQUAD(ip), HIPQUAD(*hash_ip), HIPQUAD(map->netmask)); 
    3194 +        
     3194+ 
    31953195+       for (i = 0; i < map->probes; i++) { 
    31963196+               id = jhash_ip(map, i, *hash_ip) % map->hashsize; 
     
    32153215+       ip_set_ip_t *hash_ip) 
    32163216+{ 
    3217 +       struct ip_set_req_iphash *req =  
     3217+       struct ip_set_req_iphash *req = 
    32183218+           (struct ip_set_req_iphash *) data; 
    32193219+ 
     
    32283228+ 
    32293229+static int 
    3230 +testip_kernel(struct ip_set *set,  
     3230+testip_kernel(struct ip_set *set, 
    32313231+             const struct sk_buff *skb, 
    32323232+             ip_set_ip_t *hash_ip, 
     
    32353235+{ 
    32363236+       return __testip(set, 
    3237 +                       ntohl(flags[index] & IPSET_SRC  
     3237+                       ntohl(flags[index] & IPSET_SRC 
    32383238+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    3239 +                               ? ip_hdr(skb)->saddr  
     3239+                               ? ip_hdr(skb)->saddr 
    32403240+                               : ip_hdr(skb)->daddr), 
    32413241+#else 
    3242 +                               ? skb->nh.iph->saddr  
     3242+                               ? skb->nh.iph->saddr 
    32433243+                               : skb->nh.iph->daddr), 
    32443244+#endif 
     
    32523252+       u_int16_t i; 
    32533253+       ip_set_ip_t *elem; 
    3254 +        
     3254+ 
    32553255+       if (!ip || map->elements >= limit) 
    32563256+               return -ERANGE; 
    32573257+ 
    32583258+       *hash_ip = ip & map->netmask; 
    3259 +        
     3259+ 
    32603260+       for (i = 0; i < map->probes; i++) { 
    32613261+               probe = jhash_ip(map, i, *hash_ip) % map->hashsize; 
     
    32773277+        ip_set_ip_t *hash_ip) 
    32783278+{ 
    3279 +       struct ip_set_req_iphash *req =  
     3279+       struct ip_set_req_iphash *req = 
    32803280+           (struct ip_set_req_iphash *) data; 
    32813281+ 
     
    32903290+ 
    32913291+static int 
    3292 +addip_kernel(struct ip_set *set,  
     3292+addip_kernel(struct ip_set *set, 
    32933293+            const struct sk_buff *skb, 
    32943294+            ip_set_ip_t *hash_ip, 
     
    32973297+{ 
    32983298+       return __addip((struct ip_set_iphash *) set->data, 
    3299 +                      ntohl(flags[index] & IPSET_SRC  
     3299+                      ntohl(flags[index] & IPSET_SRC 
    33003300+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    3301 +                               ? ip_hdr(skb)->saddr  
     3301+                               ? ip_hdr(skb)->saddr 
    33023302+                               : ip_hdr(skb)->daddr), 
    33033303+#else 
    3304 +                               ? skb->nh.iph->saddr  
     3304+                               ? skb->nh.iph->saddr 
    33053305+                               : skb->nh.iph->daddr), 
    33063306+#endif 
     
    33163316+       int res; 
    33173317+       struct ip_set_iphash *tmp; 
    3318 +        
     3318+ 
    33193319+       if (map->resize == 0) 
    33203320+               return -ERANGE; 
     
    33223322+    again: 
    33233323+       res = 0; 
    3324 +        
     3324+ 
    33253325+       /* Calculate new hash size */ 
    33263326+       hashsize += (hashsize * map->resize)/100; 
    33273327+       if (hashsize == map->hashsize) 
    33283328+               hashsize++; 
    3329 +        
     3329+ 
    33303330+       ip_set_printk("rehashing of set %s triggered: " 
    33313331+                     "hashsize grows from %u to %u", 
    33323332+                     set->name, map->hashsize, hashsize); 
    33333333+ 
    3334 +       tmp = kmalloc(sizeof(struct ip_set_iphash)  
     3334+       tmp = kmalloc(sizeof(struct ip_set_iphash) 
    33353335+                     + map->probes * sizeof(uint32_t), GFP_ATOMIC); 
    33363336+       if (!tmp) { 
     
    33523352+       tmp->netmask = map->netmask; 
    33533353+       memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t)); 
    3354 +        
     3354+ 
    33553355+       write_lock_bh(&set->lock); 
    33563356+       map = (struct ip_set_iphash *) set->data; /* Play safe */ 
    33573357+       for (i = 0; i < map->hashsize && res == 0; i++) { 
    3358 +               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);      
     3358+               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i); 
    33593359+               if (*elem) 
    33603360+                       res = __addip(tmp, *elem, &hash_ip); 
     
    33673367+               goto again; 
    33683368+       } 
    3369 +        
     3369+ 
    33703370+       /* Success at resizing! */ 
    33713371+       members = map->members; 
     
    33933393+       if (id == UINT_MAX) 
    33943394+               return -EEXIST; 
    3395 +                
     3395+ 
    33963396+       elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id); 
    33973397+       *elem = 0; 
     
    34183418+ 
    34193419+static int 
    3420 +delip_kernel(struct ip_set *set,  
     3420+delip_kernel(struct ip_set *set, 
    34213421+            const struct sk_buff *skb, 
    34223422+            ip_set_ip_t *hash_ip, 
     
    34253425+{ 
    34263426+       return __delip(set, 
    3427 +                      ntohl(flags[index] & IPSET_SRC  
     3427+                      ntohl(flags[index] & IPSET_SRC 
    34283428+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    3429 +                               ? ip_hdr(skb)->saddr  
     3429+                               ? ip_hdr(skb)->saddr 
    34303430+                               : ip_hdr(skb)->daddr), 
    34313431+#else 
    3432 +                               ? skb->nh.iph->saddr  
     3432+                               ? skb->nh.iph->saddr 
    34333433+                               : skb->nh.iph->daddr), 
    34343434+#endif 
     
    34603460+       } 
    34613461+ 
    3462 +       map = kmalloc(sizeof(struct ip_set_iphash)  
     3462+       map = kmalloc(sizeof(struct ip_set_iphash) 
    34633463+                     + req->probes * sizeof(uint32_t), GFP_KERNEL); 
    34643464+       if (!map) { 
     
    35283528+ 
    35293529+       for (i = 0; i < map->hashsize; i++) { 
    3530 +               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);      
     3530+               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i); 
    35313531+               ((ip_set_ip_t *)data)[i] = *elem; 
    35323532+       } 
     
    35833583+ * This program is free software; you can redistribute it and/or modify 
    35843584+ * it under the terms of the GNU General Public License version 2 as 
    3585 + * published by the Free Software Foundation.   
     3585+ * published by the Free Software Foundation. 
    35863586+ */ 
    35873587+ 
     
    36113611+{ 
    36123612+       struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data; 
    3613 +        
     3613+ 
    36143614+       if (ip < map->first_ip || ip > map->last_ip) 
    36153615+               return -ERANGE; 
     
    36253625+       ip_set_ip_t *hash_ip) 
    36263626+{ 
    3627 +       struct ip_set_req_ipmap *req =  
     3627+       struct ip_set_req_ipmap *req = 
    36283628+           (struct ip_set_req_ipmap *) data; 
    36293629+ 
     
    36383638+ 
    36393639+static int 
    3640 +testip_kernel(struct ip_set *set,  
     3640+testip_kernel(struct ip_set *set, 
    36413641+             const struct sk_buff *skb, 
    36423642+             ip_set_ip_t *hash_ip, 
     
    36473647+                       ntohl(flags[index] & IPSET_SRC 
    36483648+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    3649 +                               ? ip_hdr(skb)->saddr  
     3649+                               ? ip_hdr(skb)->saddr 
    36503650+                               : ip_hdr(skb)->daddr), 
    36513651+#else 
    3652 +                               ? skb->nh.iph->saddr  
     3652+                               ? skb->nh.iph->saddr 
    36533653+                               : skb->nh.iph->daddr), 
    36543654+#endif 
     
    36773677+      ip_set_ip_t *hash_ip) 
    36783678+{ 
    3679 +       struct ip_set_req_ipmap *req =  
     3679+       struct ip_set_req_ipmap *req = 
    36803680+           (struct ip_set_req_ipmap *) data; 
    36813681+ 
     
    36913691+ 
    36923692+static int 
    3693 +addip_kernel(struct ip_set *set,  
     3693+addip_kernel(struct ip_set *set, 
    36943694+            const struct sk_buff *skb, 
    36953695+            ip_set_ip_t *hash_ip, 
     
    36983698+{ 
    36993699+       return __addip(set, 
    3700 +                      ntohl(flags[index] & IPSET_SRC  
     3700+                      ntohl(flags[index] & IPSET_SRC 
    37013701+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    3702 +                               ? ip_hdr(skb)->saddr  
     3702+                               ? ip_hdr(skb)->saddr 
    37033703+                               : ip_hdr(skb)->daddr), 
    37043704+#else 
    3705 +                               ? skb->nh.iph->saddr  
     3705+                               ? skb->nh.iph->saddr 
    37063706+                               : skb->nh.iph->daddr), 
    37073707+#endif 
     
    37093709+} 
    37103710+ 
    3711 +static inline int  
     3711+static inline int 
    37123712+__delip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip) 
    37133713+{ 
     
    37213721+       if (!test_and_clear_bit(ip_to_id(map, *hash_ip), map->members)) 
    37223722+               return -EEXIST; 
    3723 +        
     3723+ 
    37243724+       return 0; 
    37253725+} 
     
    37493749+{ 
    37503750+       return __delip(set, 
    3751 +                      ntohl(flags[index] & IPSET_SRC  
     3751+                      ntohl(flags[index] & IPSET_SRC 
    37523752+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    3753 +                               ? ip_hdr(skb)->saddr  
     3753+                               ? ip_hdr(skb)->saddr 
    37543754+                               : ip_hdr(skb)->daddr), 
    37553755+#else 
    3756 +                               ? skb->nh.iph->saddr  
     3756+                               ? skb->nh.iph->saddr 
    37573757+                               : skb->nh.iph->daddr), 
    37583758+#endif 
     
    37983798+               unsigned int mask_bits, netmask_bits; 
    37993799+               ip_set_ip_t mask; 
    3800 +                
     3800+ 
    38013801+               map->first_ip &= map->netmask;  /* Should we better bark? */ 
    3802 +                
     3802+ 
    38033803+               mask = range_to_mask(map->first_ip, map->last_ip, &mask_bits); 
    38043804+               netmask_bits = mask_to_bits(map->netmask); 
    3805 +                
     3805+ 
    38063806+               if ((!mask && (map->first_ip || map->last_ip != 0xFFFFFFFF)) 
    38073807+                   || netmask_bits <= mask_bits) 
     
    38283828+       } 
    38293829+       memset(map->members, 0, newbytes); 
    3830 +        
     3830+ 
    38313831+       set->data = map; 
    38323832+       return 0; 
     
    38363836+{ 
    38373837+       struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data; 
    3838 +        
     3838+ 
    38393839+       kfree(map->members); 
    38403840+       kfree(map); 
    3841 +        
     3841+ 
    38423842+       set->data = NULL; 
    38433843+} 
     
    39203920+ * This program is free software; you can redistribute it and/or modify 
    39213921+ * it under the terms of the GNU General Public License version 2 as 
    3922 + * published by the Free Software Foundation.   
     3922+ * published by the Free Software Foundation. 
    39233923+ */ 
    39243924+ 
     
    39623962+       case IPPROTO_TCP: { 
    39633963+               struct tcphdr tcph; 
    3964 +                
     3964+ 
    39653965+               /* See comments at tcp_match in ip_tables.c */ 
    39663966+               if (offset) 
     
    39743974+                       /* No choice either */ 
    39753975+                       return INVALID_PORT; 
    3976 +                
     3976+ 
    39773977+               return ntohs(flags & IPSET_SRC ? 
    39783978+                            tcph.source : tcph.dest); 
     
    39913991+                       /* No choice either */ 
    39923992+                       return INVALID_PORT; 
    3993 +                
     3993+ 
    39943994+               return ntohs(flags & IPSET_SRC ? 
    39953995+                            udph.source : udph.dest); 
     
    40124012+       ip_set_ip_t *hash_ip) 
    40134013+{ 
    4014 +       struct ip_set_ipporthash *map =  
     4014+       struct ip_set_ipporthash *map = 
    40154015+               (struct ip_set_ipporthash *) set->data; 
    40164016+       __u32 id; 
     
    40214021+       DP("set: %s, ipport:%u.%u.%u.%u:%u, %u.%u.%u.%u", 
    40224022+          set->name, HIPQUAD(ip), port, HIPQUAD(*hash_ip)); 
    4023 +        
     4023+ 
    40244024+       for (i = 0; i < map->probes; i++) { 
    40254025+               id = jhash_ip(map, i, *hash_ip) % map->hashsize; 
     
    40394039+{ 
    40404040+       struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data; 
    4041 +        
     4041+ 
    40424042+       if (ip < map->first_ip || ip > map->last_ip) 
    40434043+               return -ERANGE; 
     
    40504050+       ip_set_ip_t *hash_ip) 
    40514051+{ 
    4052 +       struct ip_set_req_ipporthash *req =  
     4052+       struct ip_set_req_ipporthash *req = 
    40534053+           (struct ip_set_req_ipporthash *) data; 
    40544054+ 
     
    40634063+ 
    40644064+static int 
    4065 +testip_kernel(struct ip_set *set,  
     4065+testip_kernel(struct ip_set *set, 
    40664066+             const struct sk_buff *skb, 
    40674067+             ip_set_ip_t *hash_ip, 
     
    40744074+       if (flags[index+1] == 0) 
    40754075+               return 0; 
    4076 +                
     4076+ 
    40774077+       port = get_port(skb, flags[index+1]); 
    40784078+ 
     
    40874087+#endif 
    40884088+       DP("flag %s port %u", 
    4089 +          flags[index+1] & IPSET_SRC ? "SRC" : "DST",  
    4090 +          port);        
     4089+          flags[index+1] & IPSET_SRC ? "SRC" : "DST", 
     4090+          port); 
    40914091+       if (port == INVALID_PORT) 
    4092 +               return 0;        
     4092+               return 0; 
    40934093+ 
    40944094+       res =  __testip(set, 
    4095 +                       ntohl(flags[index] & IPSET_SRC  
     4095+                       ntohl(flags[index] & IPSET_SRC 
    40964096+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    4097 +                                       ? ip_hdr(skb)->saddr  
     4097+                                       ? ip_hdr(skb)->saddr 
    40984098+                                       : ip_hdr(skb)->daddr), 
    40994099+#else 
    4100 +                                       ? skb->nh.iph->saddr  
     4100+                                       ? skb->nh.iph->saddr 
    41014101+                                       : skb->nh.iph->daddr), 
    41024102+#endif 
     
    41044104+                       hash_ip); 
    41054105+       return (res < 0 ? 0 : res); 
    4106 +        
     4106+ 
    41074107+} 
    41084108+ 
     
    41394139+ 
    41404140+       *hash_ip = HASH_IP(map, ip, port); 
    4141 +        
     4141+ 
    41424142+       return __add_haship(map, *hash_ip); 
    41434143+} 
     
    41474147+        ip_set_ip_t *hash_ip) 
    41484148+{ 
    4149 +       struct ip_set_req_ipporthash *req =  
     4149+       struct ip_set_req_ipporthash *req = 
    41504150+           (struct ip_set_req_ipporthash *) data; 
    41514151+ 
     
    41564156+               return -EINVAL; 
    41574157+       } 
    4158 +       return __addip((struct ip_set_ipporthash *) set->data,  
     4158+       return __addip((struct ip_set_ipporthash *) set->data, 
    41594159+                       req->ip, req->port, hash_ip); 
    41604160+} 
    41614161+ 
    41624162+static int 
    4163 +addip_kernel(struct ip_set *set,  
     4163+addip_kernel(struct ip_set *set, 
    41644164+            const struct sk_buff *skb, 
    41654165+            ip_set_ip_t *hash_ip, 
     
    41714171+       if (flags[index+1] == 0) 
    41724172+               return -EINVAL; 
    4173 +                
     4173+ 
    41744174+       port = get_port(skb, flags[index+1]); 
    41754175+ 
     
    41834183+          NIPQUAD(skb->nh.iph->daddr)); 
    41844184+#endif 
    4185 +       DP("flag %s port %u",  
    4186 +          flags[index+1] & IPSET_SRC ? "SRC" : "DST",  
    4187 +          port);        
     4185+       DP("flag %s port %u", 
     4186+          flags[index+1] & IPSET_SRC ? "SRC" : "DST", 
     4187+          port); 
    41884188+       if (port == INVALID_PORT) 
    4189 +               return -EINVAL;  
     4189+               return -EINVAL; 
    41904190+ 
    41914191+       return __addip((struct ip_set_ipporthash *) set->data, 
    4192 +                      ntohl(flags[index] & IPSET_SRC  
     4192+                      ntohl(flags[index] & IPSET_SRC 
    41934193+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    4194 +                               ? ip_hdr(skb)->saddr  
     4194+                               ? ip_hdr(skb)->saddr 
    41954195+                               : ip_hdr(skb)->daddr), 
    41964196+#else 
    4197 +                               ? skb->nh.iph->saddr  
     4197+                               ? skb->nh.iph->saddr 
    41984198+                               : skb->nh.iph->daddr), 
    41994199+#endif 
     
    42104210+       int res; 
    42114211+       struct ip_set_ipporthash *tmp; 
    4212 +        
     4212+ 
    42134213+       if (map->resize == 0) 
    42144214+               return -ERANGE; 
     
    42164216+    again: 
    42174217+       res = 0; 
    4218 +        
     4218+ 
    42194219+       /* Calculate new hash size */ 
    42204220+       hashsize += (hashsize * map->resize)/100; 
    42214221+       if (hashsize == map->hashsize) 
    42224222+               hashsize++; 
    4223 +        
     4223+ 
    42244224+       ip_set_printk("rehashing of set %s triggered: " 
    42254225+                     "hashsize grows from %u to %u", 
    42264226+                     set->name, map->hashsize, hashsize); 
    42274227+ 
    4228 +       tmp = kmalloc(sizeof(struct ip_set_ipporthash)  
     4228+       tmp = kmalloc(sizeof(struct ip_set_ipporthash) 
    42294229+                     + map->probes * sizeof(uint32_t), GFP_ATOMIC); 
    42304230+       if (!tmp) { 
     
    42474247+       tmp->last_ip = map->last_ip; 
    42484248+       memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t)); 
    4249 +        
     4249+ 
    42504250+       write_lock_bh(&set->lock); 
    42514251+       map = (struct ip_set_ipporthash *) set->data; /* Play safe */ 
    42524252+       for (i = 0; i < map->hashsize && res == 0; i++) { 
    4253 +               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);      
     4253+               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i); 
    42544254+               if (*elem) 
    42554255+                       res = __add_haship(tmp, *elem); 
     
    42624262+               goto again; 
    42634263+       } 
    4264 +        
     4264+ 
    42654265+       /* Success at resizing! */ 
    42664266+       members = map->members; 
     
    42914291+       if (id == UINT_MAX) 
    42924292+               return -EEXIST; 
    4293 +                
     4293+ 
    42944294+       elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id); 
    42954295+       *elem = 0; 
     
    43164316+ 
    43174317+static int 
    4318 +delip_kernel(struct ip_set *set,  
     4318+delip_kernel(struct ip_set *set, 
    43194319+            const struct sk_buff *skb, 
    43204320+            ip_set_ip_t *hash_ip, 
     
    43264326+       if (flags[index+1] == 0) 
    43274327+               return -EINVAL; 
    4328 +                
     4328+ 
    43294329+       port = get_port(skb, flags[index+1]); 
    43304330+ 
     
    43394339+#endif 
    43404340+       DP("flag %s port %u", 
    4341 +          flags[index+1] & IPSET_SRC ? "SRC" : "DST",  
    4342 +          port);        
     4341+          flags[index+1] & IPSET_SRC ? "SRC" : "DST", 
     4342+          port); 
    43434343+       if (port == INVALID_PORT) 
    4344 +               return -EINVAL;  
     4344+               return -EINVAL; 
    43454345+ 
    43464346+       return __delip(set, 
    4347 +                      ntohl(flags[index] & IPSET_SRC  
     4347+                      ntohl(flags[index] & IPSET_SRC 
    43484348+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    4349 +                               ? ip_hdr(skb)->saddr  
     4349+                               ? ip_hdr(skb)->saddr 
    43504350+                               : ip_hdr(skb)->daddr), 
    43514351+#else 
    4352 +                               ? skb->nh.iph->saddr  
     4352+                               ? skb->nh.iph->saddr 
    43534353+                               : skb->nh.iph->daddr), 
    43544354+#endif 
     
    43814381+       } 
    43824382+ 
    4383 +       map = kmalloc(sizeof(struct ip_set_ipporthash)  
     4383+       map = kmalloc(sizeof(struct ip_set_ipporthash) 
    43844384+                     + req->probes * sizeof(uint32_t), GFP_KERNEL); 
    43854385+       if (!map) { 
     
    44514451+ 
    44524452+       for (i = 0; i < map->hashsize; i++) { 
    4453 +               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);      
     4453+               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i); 
    44544454+               ((ip_set_ip_t *)data)[i] = *elem; 
    44554455+       } 
     
    45044504+ * This program is free software; you can redistribute it and/or modify 
    45054505+ * it under the terms of the GNU General Public License version 2 as 
    4506 + * published by the Free Software Foundation.   
     4506+ * published by the Free Software Foundation. 
    45074507+ */ 
    45084508+ 
     
    45334533+/* Garbage collection interval in seconds: */ 
    45344534+#define IPTREE_GC_TIME         5*60 
    4535 +/* Sleep so many milliseconds before trying again  
    4536 + * to delete the gc timer at destroying/flushing a set */  
     4535+/* Sleep so many milliseconds before trying again 
     4536+ * to delete the gc timer at destroying/flushing a set */ 
    45374537+#define IPTREE_DESTROY_SLEEP   100 
    45384538+ 
     
    45814581+       if (!ip) 
    45824582+               return -ERANGE; 
    4583 +        
     4583+ 
    45844584+       *hash_ip = ip; 
    45854585+       ABCD(a, b, c, d, hash_ip); 
     
    45984598+       ip_set_ip_t *hash_ip) 
    45994599+{ 
    4600 +       struct ip_set_req_iptree *req =  
     4600+       struct ip_set_req_iptree *req = 
    46014601+           (struct ip_set_req_iptree *) data; 
    46024602+ 
     
    46114611+ 
    46124612+static int 
    4613 +testip_kernel(struct ip_set *set,  
     4613+testip_kernel(struct ip_set *set, 
    46144614+             const struct sk_buff *skb, 
    46154615+             ip_set_ip_t *hash_ip, 
     
    46184618+{ 
    46194619+       int res; 
    4620 +        
     4620+ 
    46214621+       DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u", 
    46224622+          flags[index] & IPSET_SRC ? "SRC" : "DST", 
     
    46304630+ 
    46314631+       res =  __testip(set, 
    4632 +                       ntohl(flags[index] & IPSET_SRC  
     4632+                       ntohl(flags[index] & IPSET_SRC 
    46334633+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    4634 +                               ? ip_hdr(skb)->saddr  
     4634+                               ? ip_hdr(skb)->saddr 
    46354635+                               : ip_hdr(skb)->daddr), 
    46364636+#else 
    4637 +                               ? skb->nh.iph->saddr  
     4637+                               ? skb->nh.iph->saddr 
    46384638+                               : skb->nh.iph->daddr), 
    46394639+#endif 
     
    46554655+               DP("alloc %u", elem);                           \ 
    46564656+       }                                                       \ 
    4657 +} while (0)     
     4657+} while (0) 
    46584658+ 
    46594659+static inline int 
     
    46674667+       unsigned char a,b,c,d; 
    46684668+       int ret = 0; 
    4669 +        
     4669+ 
    46704670+       if (!ip || map->elements >= limit) 
    46714671+               /* We could call the garbage collector 
    46724672+                * but it's probably overkill */ 
    46734673+               return -ERANGE; 
    4674 +        
     4674+ 
    46754675+       *hash_ip = ip; 
    46764676+       ABCD(a, b, c, d, hash_ip); 
     
    46974697+{ 
    46984698+       struct ip_set_iptree *map = (struct ip_set_iptree *) set->data; 
    4699 +       struct ip_set_req_iptree *req =  
     4699+       struct ip_set_req_iptree *req = 
    47004700+               (struct ip_set_req_iptree *) data; 
    47014701+ 
     
    47134713+ 
    47144714+static int 
    4715 +addip_kernel(struct ip_set *set,  
     4715+addip_kernel(struct ip_set *set, 
    47164716+            const struct sk_buff *skb, 
    47174717+            ip_set_ip_t *hash_ip, 
     
    47224722+ 
    47234723+       return __addip(set, 
    4724 +                      ntohl(flags[index] & IPSET_SRC  
     4724+                      ntohl(flags[index] & IPSET_SRC 
    47254725+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    4726 +                               ? ip_hdr(skb)->saddr  
     4726+                               ? ip_hdr(skb)->saddr 
    47274727+                               : ip_hdr(skb)->daddr), 
    47284728+#else 
    4729 +                               ? skb->nh.iph->saddr  
     4729+                               ? skb->nh.iph->saddr 
    47304730+                               : skb->nh.iph->daddr), 
    47314731+#endif 
     
    47414741+} while (0) 
    47424742+ 
    4743 +static inline int  
     4743+static inline int 
    47444744+__delip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip) 
    47454745+{ 
     
    47494749+       struct ip_set_iptreed *dtree; 
    47504750+       unsigned char a,b,c,d; 
    4751 +        
     4751+ 
    47524752+       if (!ip) 
    47534753+               return -ERANGE; 
    4754 +                
     4754+ 
    47554755+       *hash_ip = ip; 
    47564756+       ABCD(a, b, c, d, hash_ip); 
     
    47844784+ 
    47854785+static int 
    4786 +delip_kernel(struct ip_set *set,  
     4786+delip_kernel(struct ip_set *set, 
    47874787+            const struct sk_buff *skb, 
    47884788+            ip_set_ip_t *hash_ip, 
     
    47914791+{ 
    47924792+       return __delip(set, 
    4793 +                      ntohl(flags[index] & IPSET_SRC  
     4793+                      ntohl(flags[index] & IPSET_SRC 
    47944794+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    4795 +                               ? ip_hdr(skb)->saddr  
     4795+                               ? ip_hdr(skb)->saddr 
    47964796+                               : ip_hdr(skb)->daddr), 
    47974797+#else 
    4798 +                               ? skb->nh.iph->saddr  
     4798+                               ? skb->nh.iph->saddr 
    47994799+                               : skb->nh.iph->daddr), 
    48004800+#endif 
     
    48754875+       LOOP_WALK_END; 
    48764876+       write_unlock_bh(&set->lock); 
    4877 +        
     4877+ 
    48784878+       map->gc.expires = jiffies + map->gc_interval * HZ; 
    48794879+       add_timer(&map->gc); 
     
    49594959+       struct ip_set_iptree *map = (struct ip_set_iptree *) set->data; 
    49604960+       unsigned int timeout = map->timeout; 
    4961 +        
     4961+ 
    49624962+       /* gc might be running */ 
    49634963+       while (!del_timer(&map->gc)) 
     
    50225022+                       entry = (struct ip_set_req_iptree *)(data + offset); 
    50235023+                       entry->ip = ((a << 24) | (b << 16) | (c << 8) | d); 
    5024 +                       entry->timeout = !map->timeout ? 0  
     5024+                       entry->timeout = !map->timeout ? 0 
    50255025+                               : (dtree->expires[d] - jiffies)/HZ; 
    50265026+                       offset += sizeof(struct ip_set_req_iptree); 
     
    50625062+{ 
    50635063+       int ret; 
    5064 +        
     5064+ 
    50655065+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) 
    50665066+       branch_cachep = kmem_cache_create("ip_set_iptreeb", 
     
    50965096+ 
    50975097+       kmem_cache_destroy(leaf_cachep); 
    5098 +    free_branch:        
     5098+    free_branch: 
    50995099+       kmem_cache_destroy(branch_cachep); 
    51005100+    out: 
     
    54125412+       int res; 
    54135413+ 
    5414 +       res = __testip(set,  
    5415 +                      ntohl(flags[index] & IPSET_SRC  
     5414+       res = __testip(set, 
     5415+                      ntohl(flags[index] & IPSET_SRC 
    54165416+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    5417 +                               ? ip_hdr(skb)->saddr  
     5417+                               ? ip_hdr(skb)->saddr 
    54185418+                               : ip_hdr(skb)->daddr), 
    54195419+#else 
    5420 +                               ? skb->nh.iph->saddr  
     5420+                               ? skb->nh.iph->saddr 
    54215421+                               : skb->nh.iph->daddr), 
    54225422+#endif 
     
    55025502+ 
    55035503+       return __addip_single(set, 
    5504 +                       ntohl(flags[index] & IPSET_SRC  
     5504+                       ntohl(flags[index] & IPSET_SRC 
    55055505+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    5506 +                               ? ip_hdr(skb)->saddr  
     5506+                               ? ip_hdr(skb)->saddr 
    55075507+                               : ip_hdr(skb)->daddr), 
    55085508+#else 
    5509 +                               ? skb->nh.iph->saddr  
     5509+                               ? skb->nh.iph->saddr 
    55105510+                               : skb->nh.iph->daddr), 
    55115511+#endif 
     
    55875587+delip_kernel(struct ip_set *set, const struct sk_buff *skb, ip_set_ip_t *hash_ip, const u_int32_t *flags, unsigned char index) 
    55885588+{ 
    5589 +       return __delip_single(set,  
    5590 +                       ntohl(flags[index] & IPSET_SRC  
     5589+       return __delip_single(set, 
     5590+                       ntohl(flags[index] & IPSET_SRC 
    55915591+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    5592 +                               ? ip_hdr(skb)->saddr  
     5592+                               ? ip_hdr(skb)->saddr 
    55935593+                               : ip_hdr(skb)->daddr), 
    55945594+#else 
    5595 +                               ? skb->nh.iph->saddr  
     5595+                               ? skb->nh.iph->saddr 
    55965596+                               : skb->nh.iph->daddr), 
    55975597+#endif 
     
    58455845+ 
    58465846+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) 
    5847 +       cachep_b = kmem_cache_create("ip_set_iptreemap_b",  
    5848 +                                    sizeof(struct ip_set_iptreemap_b),  
     5847+       cachep_b = kmem_cache_create("ip_set_iptreemap_b", 
     5848+                                    sizeof(struct ip_set_iptreemap_b), 
    58495849+                                    0, 0, NULL); 
    58505850+#else 
    5851 +       cachep_b = kmem_cache_create("ip_set_iptreemap_b",  
    5852 +                                    sizeof(struct ip_set_iptreemap_b),  
     5851+       cachep_b = kmem_cache_create("ip_set_iptreemap_b", 
     5852+                                    sizeof(struct ip_set_iptreemap_b), 
    58535853+                                    0, 0, NULL, NULL); 
    58545854+#endif 
     
    58595859+ 
    58605860+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23) 
    5861 +       cachep_c = kmem_cache_create("ip_set_iptreemap_c",  
     5861+       cachep_c = kmem_cache_create("ip_set_iptreemap_c", 
    58625862+                                    sizeof(struct ip_set_iptreemap_c), 
    58635863+                                    0, 0, NULL); 
    58645864+#else 
    5865 +       cachep_c = kmem_cache_create("ip_set_iptreemap_c",  
     5865+       cachep_c = kmem_cache_create("ip_set_iptreemap_c", 
    58665866+                                    sizeof(struct ip_set_iptreemap_c), 
    58675867+                                    0, 0, NULL, NULL); 
     
    59545954+ * This program is free software; you can redistribute it and/or modify 
    59555955+ * it under the terms of the GNU General Public License version 2 as 
    5956 + * published by the Free Software Foundation.   
     5956+ * published by the Free Software Foundation. 
    59575957+ */ 
    59585958+ 
     
    59795979+{ 
    59805980+       struct ip_set_macipmap *map = (struct ip_set_macipmap *) set->data; 
    5981 +       struct ip_set_macip *table = (struct ip_set_macip *) map->members;       
     5981+       struct ip_set_macip *table = (struct ip_set_macip *) map->members; 
    59825982+       struct ip_set_req_macipmap *req = (struct ip_set_req_macipmap *) data; 
    59835983+ 
     
    59945994+       *hash_ip = req->ip; 
    59955995+       DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u", 
    5996 +          set->name, HIPQUAD(req->ip), HIPQUAD(*hash_ip));              
     5996+          set->name, HIPQUAD(req->ip), HIPQUAD(*hash_ip)); 
    59975997+       if (test_bit(IPSET_MACIP_ISSET, 
    59985998+                    (void *) &table[req->ip - map->first_ip].flags)) { 
     
    60066006+ 
    60076007+static int 
    6008 +testip_kernel(struct ip_set *set,  
     6008+testip_kernel(struct ip_set *set, 
    60096009+             const struct sk_buff *skb, 
    60106010+             ip_set_ip_t *hash_ip, 
     
    60176017+           (struct ip_set_macip *) map->members; 
    60186018+       ip_set_ip_t ip; 
    6019 +        
     6019+ 
    60206020+       ip = ntohl(flags[index] & IPSET_SRC 
    60216021+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    6022 +                       ? ip_hdr(skb)->saddr  
     6022+                       ? ip_hdr(skb)->saddr 
    60236023+                       : ip_hdr(skb)->daddr); 
    60246024+#else 
     
    60306030+               return 0; 
    60316031+ 
    6032 +       *hash_ip = ip;   
     6032+       *hash_ip = ip; 
    60336033+       DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u", 
    6034 +          set->name, HIPQUAD(ip), HIPQUAD(*hash_ip));           
     6034+          set->name, HIPQUAD(ip), HIPQUAD(*hash_ip)); 
    60356035+       if (test_bit(IPSET_MACIP_ISSET, 
    60366036+           (void *) &table[ip - map->first_ip].flags)) { 
     
    60546054+/* returns 0 on success */ 
    60556055+static inline int 
    6056 +__addip(struct ip_set *set,  
     6056+__addip(struct ip_set *set, 
    60576057+       ip_set_ip_t ip, unsigned char *ethernet, ip_set_ip_t *hash_ip) 
    60586058+{ 
     
    60646064+       if (ip < map->first_ip || ip > map->last_ip) 
    60656065+               return -ERANGE; 
    6066 +       if (test_and_set_bit(IPSET_MACIP_ISSET,  
     6066+       if (test_and_set_bit(IPSET_MACIP_ISSET, 
    60676067+                            (void *) &table[ip - map->first_ip].flags)) 
    60686068+               return -EEXIST; 
     
    60916091+ 
    60926092+static int 
    6093 +addip_kernel(struct ip_set *set,  
     6093+addip_kernel(struct ip_set *set, 
    60946094+            const struct sk_buff *skb, 
    60956095+            ip_set_ip_t *hash_ip, 
     
    60986098+{ 
    60996099+       ip_set_ip_t ip; 
    6100 +        
     6100+ 
    61016101+       ip = ntohl(flags[index] & IPSET_SRC 
    61026102+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    6103 +                       ? ip_hdr(skb)->saddr  
     6103+                       ? ip_hdr(skb)->saddr 
    61046104+                       : ip_hdr(skb)->daddr); 
    61056105+#else 
     
    61306130+       if (ip < map->first_ip || ip > map->last_ip) 
    61316131+               return -ERANGE; 
    6132 +       if (!test_and_clear_bit(IPSET_MACIP_ISSET,  
     6132+       if (!test_and_clear_bit(IPSET_MACIP_ISSET, 
    61336133+                               (void *)&table[ip - map->first_ip].flags)) 
    61346134+               return -EEXIST; 
     
    61636163+{ 
    61646164+       return __delip(set, 
    6165 +                      ntohl(flags[index] & IPSET_SRC  
     6165+                      ntohl(flags[index] & IPSET_SRC 
    61666166+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    6167 +                               ? ip_hdr(skb)->saddr  
     6167+                               ? ip_hdr(skb)->saddr 
    61686168+                               : ip_hdr(skb)->daddr), 
    61696169+#else 
    6170 +                               ? skb->nh.iph->saddr  
     6170+                               ? skb->nh.iph->saddr 
    61716171+                               : skb->nh.iph->daddr), 
    61726172+#endif 
     
    62256225+       } 
    62266226+       memset(map->members, 0, newbytes); 
    6227 +        
     6227+ 
    62286228+       set->data = map; 
    62296229+       return 0; 
     
    63296329+ * This program is free software; you can redistribute it and/or modify 
    63306330+ * it under the terms of the GNU General Public License version 2 as 
    6331 + * published by the Free Software Foundation.   
     6331+ * published by the Free Software Foundation. 
    63326332+ */ 
    63336333+ 
     
    63726372+ 
    63736373+       *hash_ip = pack(ip, cidr); 
    6374 +        
     6374+ 
    63756375+       for (i = 0; i < map->probes; i++) { 
    63766376+               id = jhash_ip(map, i, *hash_ip) % map->hashsize; 
     
    64176417+       ip_set_ip_t *hash_ip) 
    64186418+{ 
    6419 +       struct ip_set_req_nethash *req =  
     6419+       struct ip_set_req_nethash *req = 
    64206420+           (struct ip_set_req_nethash *) data; 
    64216421+ 
     
    64316431+ 
    64326432+static int 
    6433 +testip_kernel(struct ip_set *set,  
     6433+testip_kernel(struct ip_set *set, 
    64346434+             const struct sk_buff *skb, 
    64356435+             ip_set_ip_t *hash_ip, 
     
    64386438+{ 
    64396439+       return __testip(set, 
    6440 +                       ntohl(flags[index] & IPSET_SRC  
     6440+                       ntohl(flags[index] & IPSET_SRC 
    64416441+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    6442 +                               ? ip_hdr(skb)->saddr  
     6442+                               ? ip_hdr(skb)->saddr 
    64436443+                               : ip_hdr(skb)->daddr), 
    64446444+#else 
    6445 +                               ? skb->nh.iph->saddr  
     6445+                               ? skb->nh.iph->saddr 
    64466446+                               : skb->nh.iph->daddr), 
    64476447+#endif 
     
    64556455+       u_int16_t i; 
    64566456+       ip_set_ip_t *elem; 
    6457 +        
     6457+ 
    64586458+       for (i = 0; i < map->probes; i++) { 
    64596459+               probe = jhash_ip(map, i, ip) % map->hashsize; 
     
    64776477+       if (!ip || map->elements >= limit) 
    64786478+               return -ERANGE; 
    6479 +        
     6479+ 
    64806480+       *hash_ip = pack(ip, cidr); 
    64816481+       DP("%u.%u.%u.%u/%u, %u.%u.%u.%u", HIPQUAD(ip), cidr, HIPQUAD(*hash_ip)); 
    6482 +        
     6482+ 
    64836483+       return __addip_base(map, *hash_ip); 
    64846484+} 
     
    64896489+       unsigned char next; 
    64906490+       int i; 
    6491 +        
     6491+ 
    64926492+       for (i = 0; i < 30 && map->cidr[i]; i++) { 
    64936493+               if (map->cidr[i] == cidr) { 
     
    65076507+        ip_set_ip_t *hash_ip) 
    65086508+{ 
    6509 +       struct ip_set_req_nethash *req =  
     6509+       struct ip_set_req_nethash *req = 
    65106510+           (struct ip_set_req_nethash *) data; 
    65116511+       int ret; 
     
    65176517+               return -EINVAL; 
    65186518+       } 
    6519 +       ret = __addip((struct ip_set_nethash *) set->data,  
     6519+       ret = __addip((struct ip_set_nethash *) set->data, 
    65206520+                     req->ip, req->cidr, hash_ip); 
    6521 +        
     6521+ 
    65226522+       if (ret == 0) 
    65236523+               update_cidr_sizes((struct ip_set_nethash *) set->data, 
    65246524+                                 req->cidr); 
    6525 +        
     6525+ 
    65266526+       return ret; 
    65276527+} 
    65286528+ 
    65296529+static int 
    6530 +addip_kernel(struct ip_set *set,  
     6530+addip_kernel(struct ip_set *set, 
    65316531+            const struct sk_buff *skb, 
    65326532+            ip_set_ip_t *hash_ip, 
     
    65366536+       struct ip_set_nethash *map = (struct ip_set_nethash *) set->data; 
    65376537+       int ret = -ERANGE; 
    6538 +       ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC  
     6538+       ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC 
    65396539+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    6540 +                                       ? ip_hdr(skb)->saddr  
     6540+                                       ? ip_hdr(skb)->saddr 
    65416541+                                       : ip_hdr(skb)->daddr); 
    65426542+#else 
     
    65446544+                                       : skb->nh.iph->daddr); 
    65456545+#endif 
    6546 +        
     6546+ 
    65476547+       if (map->cidr[0]) 
    65486548+               ret = __addip(map, ip, map->cidr[0], hash_ip); 
    6549 +                
     6549+ 
    65506550+       return ret; 
    65516551+} 
     
    65596559+       int res; 
    65606560+       struct ip_set_nethash *tmp; 
    6561 +        
     6561+ 
    65626562+       if (map->resize == 0) 
    65636563+               return -ERANGE; 
     
    65656565+    again: 
    65666566+       res = 0; 
    6567 +        
     6567+ 
    65686568+       /* Calculate new parameters */ 
    65696569+       hashsize += (hashsize * map->resize)/100; 
    65706570+       if (hashsize == map->hashsize) 
    65716571+               hashsize++; 
    6572 +        
     6572+ 
    65736573+       ip_set_printk("rehashing of set %s triggered: " 
    65746574+                     "hashsize grows from %u to %u", 
    65756575+                     set->name, map->hashsize, hashsize); 
    65766576+ 
    6577 +       tmp = kmalloc(sizeof(struct ip_set_nethash)  
     6577+       tmp = kmalloc(sizeof(struct ip_set_nethash) 
    65786578+                     + map->probes * sizeof(uint32_t), GFP_ATOMIC); 
    65796579+       if (!tmp) { 
     
    65956595+       memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t)); 
    65966596+       memcpy(tmp->cidr, map->cidr, 30 * sizeof(unsigned char)); 
    6597 +        
     6597+ 
    65986598+       write_lock_bh(&set->lock); 
    65996599+       map = (struct ip_set_nethash *) set->data; /* Play safe */ 
    66006600+       for (i = 0; i < map->hashsize && res == 0; i++) { 
    6601 +               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);      
     6601+               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i); 
    66026602+               if (*elem) 
    66036603+                       res = __addip_base(tmp, *elem); 
     
    66106610+               goto again; 
    66116611+       } 
    6612 +        
     6612+ 
    66136613+       /* Success at resizing! */ 
    66146614+       members = map->members; 
    6615 +        
     6615+ 
    66166616+       map->hashsize = tmp->hashsize; 
    66176617+       map->members = tmp->members; 
     
    66326632+       if (!ip) 
    66336633+               return -ERANGE; 
    6634 +        
     6634+ 
    66356635+       id = hash_id_cidr(map, ip, cidr, hash_ip); 
    66366636+       if (id == UINT_MAX) 
    66376637+               return -EEXIST; 
    6638 +                
     6638+ 
    66396639+       elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id); 
    66406640+       *elem = 0; 
     
    66566656+               return -EINVAL; 
    66576657+       } 
    6658 +       /* TODO: no garbage collection in map->cidr */           
    6659 +       return __delip((struct ip_set_nethash *) set->data,  
     6658+       /* TODO: no garbage collection in map->cidr */ 
     6659+       return __delip((struct ip_set_nethash *) set->data, 
    66606660+                      req->ip, req->cidr, hash_ip); 
    66616661+} 
    66626662+ 
    66636663+static int 
    6664 +delip_kernel(struct ip_set *set,  
     6664+delip_kernel(struct ip_set *set, 
    66656665+            const struct sk_buff *skb, 
    66666666+            ip_set_ip_t *hash_ip, 
     
    66706670+       struct ip_set_nethash *map = (struct ip_set_nethash *) set->data; 
    66716671+       int ret = -ERANGE; 
    6672 +       ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC  
     6672+       ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC 
    66736673+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) 
    6674 +                                       ? ip_hdr(skb)->saddr  
     6674+                                       ? ip_hdr(skb)->saddr 
    66756675+                                       : ip_hdr(skb)->daddr); 
    66766676+#else 
     
    66786678+                                       : skb->nh.iph->daddr); 
    66796679+#endif 
    6680 +        
     6680+ 
    66816681+       if (map->cidr[0]) 
    66826682+               ret = __delip(map, ip, map->cidr[0], hash_ip); 
    6683 +        
     6683+ 
    66846684+       return ret; 
    66856685+} 
     
    67296729+               return -ENOMEM; 
    67306730+       } 
    6731 +        
     6731+ 
    67326732+       set->data = map; 
    67336733+       return 0; 
     
    67766776+ 
    67776777+       for (i = 0; i < map->hashsize; i++) { 
    6778 +               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);      
     6778+               elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i); 
    67796779+               ((ip_set_ip_t *)data)[i] = *elem; 
    67806780+       } 
     
    68296829+ * This program is free software; you can redistribute it and/or modify 
    68306830+ * it under the terms of the GNU General Public License version 2 as 
    6831 + * published by the Free Software Foundation.   
     6831+ * published by the Free Software Foundation. 
    68326832+ */ 
    68336833+ 
     
    68646864+       case IPPROTO_TCP: { 
    68656865+               struct tcphdr tcph; 
    6866 +                
     6866+ 
    68676867+               /* See comments at tcp_match in ip_tables.c */ 
    68686868+               if (offset) 
     
    68766876+                       /* No choice either */ 
    68776877+                       return INVALID_PORT; 
    6878 +                
     6878+ 
    68796879+               return ntohs(flags & IPSET_SRC ? 
    68806880+                            tcph.source : tcph.dest); 
     
    68936893+                       /* No choice either */ 
    68946894+                       return INVALID_PORT; 
    6895 +                
     6895+ 
    68966896+               return ntohs(flags & IPSET_SRC ? 
    68976897+                            udph.source : udph.dest); 
     
    69096909+       if (port < map->first_port || port > map->last_port) 
    69106910+               return -ERANGE; 
    6911 +                
     6911+ 
    69126912+       *hash_port = port; 
    69136913+       DP("set: %s, port:%u, %u", set->name, port, *hash_port); 
     
    69196919+         ip_set_ip_t *hash_port) 
    69206920+{ 
    6921 +       struct ip_set_req_portmap *req =  
     6921+       struct ip_set_req_portmap *req = 
    69226922+           (struct ip_set_req_portmap *) data; 
    69236923+ 
     
    69326932+ 
    69336933+static int 
    6934 +testport_kernel(struct ip_set *set,  
     6934+testport_kernel(struct ip_set *set, 
    69356935+               const struct sk_buff *skb, 
    69366936+               ip_set_ip_t *hash_port, 
     
    69416941+       ip_set_ip_t port = get_port(skb, flags[index]); 
    69426942+ 
    6943 +       DP("flag %s port %u", flags[index] & IPSET_SRC ? "SRC" : "DST", port);   
     6943+       DP("flag %s port %u", flags[index] & IPSET_SRC ? "SRC" : "DST", port); 
    69446944+       if (port == INVALID_PORT) 
    6945 +               return 0;        
     6945+               return 0; 
    69466946+ 
    69476947+       res =  __testport(set, port, hash_port); 
    6948 +        
     6948+ 
    69496949+       return (res < 0 ? 0 : res); 
    69506950+} 
     
    69596959+       if (test_and_set_bit(port - map->first_port, map->members)) 
    69606960+               return -EEXIST; 
    6961 +                
     6961+ 
    69626962+       *hash_port = port; 
    69636963+       DP("port %u", port); 
     
    69696969+        ip_set_ip_t *hash_port) 
    69706970+{ 
    6971 +       struct ip_set_req_portmap *req =  
     6971+       struct ip_set_req_portmap *req = 
    69726972+           (struct ip_set_req_portmap *) data; 
    69736973+ 
     
    69826982+ 
    69836983+static int 
    6984 +addport_kernel(struct ip_set *set,  
     6984+addport_kernel(struct ip_set *set, 
    69856985+              const struct sk_buff *skb, 
    69866986+              ip_set_ip_t *hash_port, 
     
    69896989+{ 
    69906990+       ip_set_ip_t port = get_port(skb, flags[index]); 
    6991 +        
     6991+ 
    69926992+       if (port == INVALID_PORT) 
    69936993+               return -EINVAL; 
     
    70057005+       if (!test_and_clear_bit(port - map->first_port, map->members)) 
    70067006+               return -EEXIST; 
    7007 +                
     7007+ 
    70087008+       *hash_port = port; 
    70097009+       DP("port %u", port); 
     
    70287028+ 
    70297029+static int 
    7030 +delport_kernel(struct ip_set *set,  
     7030+delport_kernel(struct ip_set *set, 
    70317031+              const struct sk_buff *skb, 
    70327032+              ip_set_ip_t *hash_port, 
     
    70357035+{ 
    70367036+       ip_set_ip_t port = get_port(skb, flags[index]); 
    7037 +        
     7037+ 
    70387038+       if (port == INVALID_PORT) 
    70397039+               return -EINVAL; 
     
    71817181+ * This program is free software; you can redistribute it and/or modify 
    71827182+ * it under the terms of the GNU General Public License version 2 as 
    7183 + * published by the Free Software Foundation.   
     7183+ * published by the Free Software Foundation. 
    71847184+ */ 
    71857185+ 
     
    71997199+         const struct sk_buff *skb, 
    72007200+         int inv) 
    7201 +{       
     7201+{ 
    72027202+       if (ip_set_testip_kernel(info->index, skb, info->flags)) 
    72037203+               inv = !inv; 
     
    72267226+{ 
    72277227+       const struct ipt_set_info_match *info = matchinfo; 
    7228 +                
     7228+ 
    72297229+       return match_set(&info->match_set, 
    72307230+                        skb, 
     
    72527252+          unsigned int hook_mask) 
    72537253+{ 
    7254 +       struct ipt_set_info_match *info =  
     7254+       struct ipt_set_info_match *info = 
    72557255+               (struct ipt_set_info_match *) matchinfo; 
    72567256+       ip_set_id_t index; 
     
    72647264+ 
    72657265+       index = ip_set_get_byindex(info->match_set.index); 
    7266 +                
     7266+ 
    72677267+       if (index == IP_SET_INVALID_ID) { 
    72687268+               ip_set_printk("Cannot find set indentified by id %u to match", 
     
    73447344+ * This program is free software; you can redistribute it and/or modify 
    73457345+ * it under the terms of the GNU General Public License version 2 as 
    7346 + * published by the Free Software Foundation.   
     7346+ * published by the Free Software Foundation. 
    73477347+ */ 
    73487348+ 
     
    73877387+       struct sk_buff *skb = *pskb; 
    73887388+#endif 
    7389 +        
     7389+ 
    73907390+       if (info->add_set.index != IP_SET_INVALID_ID) 
    73917391+               ip_set_addip_kernel(info->add_set.index, 
     
    74167416+          void *targinfo, 
    74177417+#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) 
    7418 +          unsigned int targinfosize,  
     7418+          unsigned int targinfosize, 
    74197419+#endif 
    74207420+          unsigned int hook_mask) 
    74217421+{ 
    7422 +       struct ipt_set_info_target *info =  
     7422+       struct ipt_set_info_target *info = 
    74237423+               (struct ipt_set_info_target *) targinfo; 
    74247424+       ip_set_id_t index; 
  • trunk/target/linux/generic-2.6/patches-2.6.26/150-netfilter_imq.patch

    r11569 r11945  
    5151+ * 
    5252+ * 
    53 + *             2008/06/17 - 2.6.25 - Changed imq.c to use qdisc_run() instead  
     53+ *             2008/06/17 - 2.6.25 - Changed imq.c to use qdisc_run() instead 
    5454+ *            of qdisc_restart() and moved qdisc_run() to tasklet to avoid 
    5555+ *             recursive locking. New initialization routines to fix 'rmmod' not 
    5656+ *             working anymore. Used code from ifb.c. (Jussi Kivilinna) 
    57 + *             
     57+ * 
    5858+ *            Also, many thanks to pablo Sebastian Greco for making the initial 
    5959+ *            patch and to those who helped the testing. 
  • trunk/target/linux/generic-2.6/patches-2.6.26/200-sched_esfq.patch

    r11768 r11945  
    55  *     The only reason for this is efficiency, it is possible 
    66  *     to change these parameters in compile time. 
    7 + *      
     7+ * 
    88+ *     If you need to play with these values, use esfq instead. 
    99  */ 
     
    6161+         several other hashing methods, such as by src IP or by dst IP, which 
    6262+         can be more fair to users in some networking situations. 
    63 +          
     63+ 
    6464+         To compile this code as a module, choose M here: the 
    6565+         module will be called sch_esfq. 
     
    150150+       The difference is that you can change limit, depth, 
    151151+       hash table size and choose alternate hash types. 
    152 +        
     152+ 
    153153+       classic:        same as in sch_sfq.c 
    154154+       dst:            destination IP address 
     
    158158+       ctorigsrc:      original source IP address 
    159159+       ctrepldst:      reply destination IP address 
    160 +       ctreplsrc:      reply source IP  
    161 +        
     160+       ctreplsrc:      reply source IP 
     161+ 
    162162+*/ 
    163163+ 
     
    232232+       struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 
    233233+#endif 
    234 +        
     234+ 
    235235+       switch (skb->protocol) { 
    236236+       case __constant_htons(ETH_P_IP): 
     
    490490+       if (q->tail == depth) 
    491491+               return NULL; 
    492 +        
     492+ 
    493493+       a = old_a = q->next[q->tail]; 
    494 +        
     494+ 
    495495+       /* Grab packet */ 
    496496+       skb = __skb_dequeue(&q->qs[a]); 
    497497+       esfq_dec(q, a); 
    498 +        
     498+ 
    499499+       /* Is the slot empty? */ 
    500500+       if (q->qs[a].qlen == 0) { 
     
    512512+               q->allot[a] += q->quantum; 
    513513+       } 
    514 +        
     514+ 
    515515+       return skb; 
    516516+} 
     
    602602+       } 
    603603+} 
    604 +        
     604+ 
    605605+static int esfq_q_init(struct esfq_sched_data *q, struct rtattr *opt) 
    606606+{ 
     
    608608+       esfq_index p = ~0U/2; 
    609609+       int i; 
    610 +        
     610+ 
    611611+       if (opt && opt->rta_len < RTA_LENGTH(sizeof(*ctl))) 
    612612+               return -EINVAL; 
     
    619619+               q->hash_divisor = 1024; 
    620620+               q->tail = q->limit = q->depth = 128; 
    621 +                
     621+ 
    622622+       } else { 
    623623+               struct tc_esfq_qopt *ctl = RTA_DATA(opt); 
     
    627627+               q->hash_divisor = ctl->divisor ? : 1024; 
    628628+               q->tail = q->limit = q->depth = ctl->flows ? : 128; 
    629 +                
     629+ 
    630630+               if ( q->depth > p - 1 ) 
    631631+                       return -EINVAL; 
    632 +                
     632+ 
    633633+               if (ctl->limit) 
    634634+                       q->limit = min_t(u32, ctl->limit, q->depth); 
    635 +                
     635+ 
    636636+               if (ctl->hash_kind) { 
    637637+                       q->hash_kind = esfq_check_hash(ctl->hash_kind); 
    638638+               } 
    639639+       } 
    640 +        
     640+ 
    641641+       q->ht = kmalloc(q->hash_divisor*sizeof(esfq_index), GFP_KERNEL); 
    642642+       if (!q->ht) 
     
    657657+       if (!q->qs) 
    658658+               goto err_case; 
    659 +        
     659+ 
    660660+       for (i=0; i< q->hash_divisor; i++) 
    661661+               q->ht[i] = q->depth; 
     
    665665+               q->dep[i+q->depth].prev = i+q->depth; 
    666666+       } 
    667 +        
     667+ 
    668668+       for (i=0; i<q->depth; i++) 
    669669+               esfq_link(q, i); 
     
    678678+       struct esfq_sched_data *q = qdisc_priv(sch); 
    679679+       int err; 
    680 +        
     680+ 
    681681+       q->quantum = psched_mtu(sch->dev); /* default */ 
    682682+       if ((err = esfq_q_init(q, opt))) 
     
    690690+               add_timer(&q->perturb_timer); 
    691691+       } 
    692 +        
     692+ 
    693693+       return 0; 
    694694+} 
     
    700700+       struct sk_buff *skb; 
    701701+       int err; 
    702 +        
     702+ 
    703703+       /* set up new queue */ 
    704704+       memset(&new, 0, sizeof(struct esfq_sched_data)); 
     
    711711+       while ((skb = esfq_q_dequeue(q)) != NULL) 
    712712+               esfq_q_enqueue(skb, &new, ESFQ_TAIL); 
    713 +        
     713+ 
    714714+       /* clean up the old queue */ 
    715715+       esfq_q_destroy(q); 
     
    787787+       return register_qdisc(&esfq_qdisc_ops); 
    788788+} 
    789 +static void __exit esfq_module_exit(void)  
     789+static void __exit esfq_module_exit(void) 
    790790+{ 
    791791+       unregister_qdisc(&esfq_qdisc_ops); 
  • trunk/target/linux/generic-2.6/patches-2.6.26/204-jffs2_eofdetect.patch

    r11336 r11945  
    1010+                       c->mtd->unlock(c->mtd, 0, c->mtd->size); 
    1111+               printk("done.\n"); 
    12 +                
     12+ 
    1313+               printk("%s(): erasing all blocks after the end marker... ", __func__); 
    1414+               jffs2_erase_pending_blocks(c, -1); 
     
    2121--- a/fs/jffs2/scan.c 
    2222+++ b/fs/jffs2/scan.c 
    23 @@ -143,9 +143,12 @@ 
    24   
     23@@ -72,7 +72,7 @@ 
     24                return ret; 
     25        if ((ret = jffs2_scan_dirty_space(c, jeb, jeb->free_size))) 
     26                return ret; 
     27-       /* Turned wasted size into dirty, since we apparently  
     28+       /* Turned wasted size into dirty, since we apparently 
     29           think it's recoverable now. */ 
     30        jeb->dirty_size += jeb->wasted_size; 
     31        c->dirty_size += jeb->wasted_size; 
     32@@ -144,8 +144,11 @@ 
    2533                /* reset summary info for next eraseblock scan */ 
    2634                jffs2_sum_reset_collected(s); 
    27 - 
     35  
    2836-               ret = jffs2_scan_eraseblock(c, jeb, buf_size?flashbuf:(flashbuf+jeb->offset), 
    2937-                                               buf_size, s); 
    30 +                
    3138+               if (c->flags & (1 << 7)) 
    3239+                       ret = BLK_STATE_ALLFF; 
     
    3744                if (ret < 0) 
    3845                        goto out; 
     46@@ -400,7 +403,7 @@ 
     47        if (!ref) 
     48                return -ENOMEM; 
     49  
     50-       /* BEFORE jffs2_build_xattr_subsystem() called,  
     51+       /* BEFORE jffs2_build_xattr_subsystem() called, 
     52         * and AFTER xattr_ref is marked as a dead xref, 
     53         * ref->xid is used to store 32bit xid, xd is not used 
     54         * ref->ino is used to store 32bit inode-number, ic is not used 
     55@@ -473,7 +476,7 @@ 
     56                struct jffs2_sum_marker *sm; 
     57                void *sumptr = NULL; 
     58                uint32_t sumlen; 
     59-              
     60+ 
     61                if (!buf_size) { 
     62                        /* XIP case. Just look, point at the summary if it's there */ 
     63                        sm = (void *)buf + c->sector_size - sizeof(*sm); 
     64@@ -489,9 +492,9 @@ 
     65                                buf_len = sizeof(*sm); 
     66  
     67                        /* Read as much as we want into the _end_ of the preallocated buffer */ 
     68-                       err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len,  
     69+                       err = jffs2_fill_scan_buf(c, buf + buf_size - buf_len, 
     70                                                  jeb->offset + c->sector_size - buf_len, 
     71-                                                 buf_len);                              
     72+                                                 buf_len); 
     73                        if (err) 
     74                                return err; 
     75  
     76@@ -510,9 +513,9 @@ 
     77                                } 
     78                                if (buf_len < sumlen) { 
     79                                        /* Need to read more so that the entire summary node is present */ 
     80-                                       err = jffs2_fill_scan_buf(c, sumptr,  
     81+                                       err = jffs2_fill_scan_buf(c, sumptr, 
     82                                                                  jeb->offset + c->sector_size - sumlen, 
     83-                                                                 sumlen - buf_len);                             
     84+                                                                 sumlen - buf_len); 
     85                                        if (err) 
     86                                                return err; 
     87                                } 
     88@@ -525,7 +528,7 @@ 
     89  
     90                        if (buf_size && sumlen > buf_size) 
     91                                kfree(sumptr); 
     92-                       /* If it returns with a real error, bail.  
     93+                       /* If it returns with a real error, bail. 
     94                           If it returns positive, that's a block classification 
     95                           (i.e. BLK_STATE_xxx) so return that too. 
     96                           If it returns zero, fall through to full scan. */ 
    3997@@ -546,6 +549,17 @@ 
    4098                        return err; 
     
    51109+               return BLK_STATE_ALLFF; 
    52110+       } 
    53 +        
     111+ 
    54112        /* We temporarily use 'ofs' as a pointer into the buffer/jeb */ 
    55113        ofs = 0; 
    56114  
     115@@ -671,7 +685,7 @@ 
     116                                scan_end = buf_len; 
     117                                goto more_empty; 
     118                        } 
     119-                        
     120+ 
     121                        /* See how much more there is to read in this eraseblock... */ 
     122                        buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs); 
     123                        if (!buf_len) { 
     124@@ -907,7 +921,7 @@ 
     125  
     126        D1(printk(KERN_DEBUG "Block at 0x%08x: free 0x%08x, dirty 0x%08x, unchecked 0x%08x, used 0x%08x, wasted 0x%08x\n", 
     127                  jeb->offset,jeb->free_size, jeb->dirty_size, jeb->unchecked_size, jeb->used_size, jeb->wasted_size)); 
     128-        
     129+ 
     130        /* mark_node_obsolete can add to wasted !! */ 
     131        if (jeb->wasted_size) { 
     132                jeb->dirty_size += jeb->wasted_size; 
  • trunk/target/linux/generic-2.6/patches-2.6.26/213-kobject_uevent.patch

    r11336 r11945  
    2222+       seq = ++uevent_seqnum; 
    2323+       spin_unlock(&sequence_lock); 
    24 +        
     24+ 
    2525+       return seq; 
    2626+} 
  • trunk/target/linux/generic-2.6/patches-2.6.26/600-phy_extension.patch

    r11336 r11945  
    2121+                       return -EFAULT; 
    2222+               return 0; 
    23 +        
     23+ 
    2424+       case ETHTOOL_SSET: 
    2525+               if (copy_from_user(&ecmd, useraddr, sizeof(ecmd))) 
     
    3434+                       phy_write(phydev, MII_BMCR, tmp); 
    3535+                       return 0; 
    36 +               }        
     36+               } 
    3737+               return -EINVAL; 
    3838+ 
     
    5252  * phy_mii_ioctl - generic PHY MII ioctl interface 
    5353  * @phydev: the phy_device struct 
     54@@ -403,8 +447,8 @@ 
     55                } 
     56  
     57                phy_write(phydev, mii_data->reg_num, val); 
     58-                
     59-               if (mii_data->reg_num == MII_BMCR  
     60+ 
     61+               if (mii_data->reg_num == MII_BMCR 
     62                                && val & BMCR_RESET 
     63                                && phydev->drv->config_init) { 
     64                        phy_scan_fixups(phydev); 
     65@@ -524,7 +568,7 @@ 
     66        int idx; 
     67  
     68        idx = phy_find_setting(phydev->speed, phydev->duplex); 
     69-        
     70+ 
     71        idx++; 
     72  
     73        idx = phy_find_valid(idx, phydev->supported); 
    5474--- a/include/linux/phy.h 
    5575+++ b/include/linux/phy.h 
  • trunk/target/linux/generic-2.6/patches-2.6.26/903-hostap_txpower.patch

    r11296 r11945  
    8181+ 
    8282+       if ( val == HFA384X_LINKSTATUS_CONNECTED || 
    83 +            val == HFA384X_LINKSTATUS_DISCONNECTED )  
     83+            val == HFA384X_LINKSTATUS_DISCONNECTED ) 
    8484+                       hostap_restore_power(local->dev); 
    8585+ 
     
    128128+        struct hostap_interface *iface = dev->priv; 
    129129+       local_info_t *local = iface->local; 
    130 +                
     130+ 
    131131+       u16 val; 
    132132+       int ret = 0; 
  • trunk/target/linux/generic-2.6/patches-2.6.26/910-cryptodev_backport.patch

    r11830 r11945  
    574574--- a/crypto/crc32c.c 
    575575+++ b/crypto/crc32c.c 
    576 @@ -5,20 +5,23 @@ 
     576@@ -1,24 +1,27 @@ 
     577-/*  
     578+/* 
     579  * Cryptographic API. 
     580  * 
     581  * CRC32C chksum 
    577582  * 
    578583  * This module file is a wrapper to invoke the lib/crc32c routines. 
     
    582587  * This program is free software; you can redistribute it and/or modify it 
    583588  * under the terms of the GNU General Public License as published by the Free 
    584   * Software Foundation; either version 2 of the License, or (at your option)  
     589- * Software Foundation; either version 2 of the License, or (at your option)  
     590+ * Software Foundation; either version 2 of the License, or (at your option) 
    585591  * any later version. 
    586592  * 
     
    600606  
    601607 struct chksum_ctx { 
    602 @@ -71,7 +74,7 @@ 
     608@@ -27,7 +30,7 @@ 
     609 }; 
     610  
     611 /* 
     612- * Steps through buffer one byte at at time, calculates reflected  
     613+ * Steps through buffer one byte at at time, calculates reflected 
     614  * crc using table. 
     615  */ 
     616  
     617@@ -67,11 +70,11 @@ 
     618 static void chksum_final(struct crypto_tfm *tfm, u8 *out) 
     619 { 
     620        struct chksum_ctx *mctx = crypto_tfm_ctx(tfm); 
     621-        
     622+ 
    603623        *(__le32 *)out = ~cpu_to_le32(mctx->crc); 
    604624 } 
     
    676696+{ 
    677697+       u32 *crcp = ahash_request_ctx(req); 
    678 +        
     698+ 
    679699+       *(__le32 *)req->result = ~cpu_to_le32p(crcp); 
    680700+       return 0; 
     
    83308350+/* 
    83318351+ * Hash: Hash algorithms under the crypto API 
    8332 + *  
     8352+ * 
    83338353+ * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 
    83348354+ * 
    83358355+ * This program is free software; you can redistribute it and/or modify it 
    83368356+ * under the terms of the GNU General Public License as published by the Free 
    8337 + * Software Foundation; either version 2 of the License, or (at your option)  
     8357+ * Software Foundation; either version 2 of the License, or (at your option) 
    83388358+ * any later version. 
    83398359+ * 
     
    84878507+/* 
    84888508+ * Hash algorithms. 
    8489 + *  
     8509+ * 
    84908510+ * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au> 
    84918511+ * 
    84928512+ * This program is free software; you can redistribute it and/or modify it 
    84938513+ * under the terms of the GNU General Public License as published by the Free 
    8494 + * Software Foundation; either version 2 of the License, or (at your option)  
     8514+ * Software Foundation; either version 2 of the License, or (at your option) 
    84958515+ * any later version. 
    84968516+ * 
  • trunk/target/linux/generic-2.6/patches-2.6.26/915-hso-backport.patch

    r11938 r11945  
    2727--- 
    2828 
    29 diff --git a/drivers/net/Makefile b/drivers/net/Makefile 
    30 index c52738a..c96fe20 100644 
    3129--- a/drivers/net/Makefile 
    3230+++ b/drivers/net/Makefile 
    33 @@ -237,6 +237,7 @@ obj-$(CONFIG_USB_CATC)          += usb/ 
     31@@ -237,6 +237,7 @@ 
    3432 obj-$(CONFIG_USB_KAWETH)        += usb/ 
    3533 obj-$(CONFIG_USB_PEGASUS)       += usb/ 
     
    3937 obj-$(CONFIG_USB_ZD1201)        += usb/ 
    4038  
    41 diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig 
    42 index 0604f3f..68e198b 100644 
    4339--- a/drivers/net/usb/Kconfig 
    4440+++ b/drivers/net/usb/Kconfig 
    45 @@ -154,6 +154,16 @@ config USB_NET_AX8817X 
     41@@ -154,6 +154,16 @@ 
    4642          This driver creates an interface named "ethX", where X depends on 
    4743          what other networking devices you have in use. 
     
    6056 config USB_NET_CDCETHER 
    6157        tristate "CDC Ethernet support (smart devices such as cable modems)" 
    62 diff --git a/drivers/net/usb/Makefile b/drivers/net/usb/Makefile 
    63 index 595a539..24800c1 100644 
    6458--- a/drivers/net/usb/Makefile 
    6559+++ b/drivers/net/usb/Makefile 
    66 @@ -6,6 +6,7 @@ obj-$(CONFIG_USB_CATC)          += catc.o 
     60@@ -6,6 +6,7 @@ 
    6761 obj-$(CONFIG_USB_KAWETH)       += kaweth.o 
    6862 obj-$(CONFIG_USB_PEGASUS)      += pegasus.o 
     
    7266 obj-$(CONFIG_USB_NET_CDCETHER) += cdc_ether.o 
    7367 obj-$(CONFIG_USB_NET_DM9601)   += dm9601.o 
    74 diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c 
    75 new file mode 100644 
    76 index 0000000..031d07b 
    7768--- /dev/null 
    7869+++ b/drivers/net/usb/hso.c 
  • trunk/target/linux/generic-2.6/patches-2.6.26/970-ocf_20080704.patch

    r11803 r11945  
    8787+       int count; 
    8888+ 
    89 +       wait_event_interruptible(random_write_wait,  
     89+       wait_event_interruptible(random_write_wait, 
    9090+                        input_pool.entropy_count < random_write_wakeup_thresh); 
    9191+ 
     
    9393+ 
    9494+        /* likely we got woken up due to a signal */ 
    95 +       if (count <= 0) count = random_read_wakeup_thresh;  
     95+       if (count <= 0) count = random_read_wakeup_thresh; 
    9696+ 
    9797+       DEBUG_ENT("requesting %d bits from input_wait()er %d<%d\n", 
     
    644644+          cd linux-2.4*; gunzip < ocf-linux-24-XXXXXXXX.patch.gz | patch -p1 
    645645+          cd linux-2.6*; gunzip < ocf-linux-26-XXXXXXXX.patch.gz | patch -p1 
    646 +     
     646+ 
    647647+      if you do one of the above,  then you can proceed to the next step, 
    648648+      or you can do the above process by hand with using the patches against 
     
    667667+      recent versions of the kernels.  The same patches should also work 
    668668+      relatively easily on kernels as old as 2.6.11 and 2.4.18. 
    669 +       
     669+ 
    670670+    * under 2.4 if you are on a non-x86 platform,  you may need to: 
    671671+ 
     
    870870+ *                     mac-key + rc4-key 
    871871+ * MAX_RESULT  = base result + mac result + mac + encrypt result 
    872 + *                      
     872+ * 
    873873+ * 
    874874+ */ 
     
    12281228+ 
    12291229+/********************************************************************* 
    1230 + * Structs for board commands  
     1230+ * Structs for board commands 
    12311231+ * 
    12321232+ *********************************************************************/ 
     
    14381438+       /* 
    14391439+        *  Our current positions for insertion and removal from the desriptor 
    1440 +        *  rings.  
     1440+        *  rings. 
    14411441+        */ 
    14421442+       int                     cmdi, srci, dsti, resi; 
     
    15601560+ *  session_num 
    15611561+ *  ----------- 
    1562 + *  A number between 0 and 2048 (for DRAM models) or a number between  
     1562+ *  A number between 0 and 2048 (for DRAM models) or a number between 
    15631563+ *  0 and 768 (for SRAM models).  Those who don't want to use session 
    15641564+ *  numbers should leave value at zero and send a new crypt key and/or 
     
    15741574+ *  Either fill in the mbuf pointer and npa=0 or 
    15751575+ *      fill packp[] and packl[] and set npa to > 0 
    1576 + *  
     1576+ * 
    15771577+ *  mac_header_skip 
    15781578+ *  --------------- 
     
    16621662+ * 
    16631663+ *  Defines for negative error codes are: 
    1664 + *   
     1664+ * 
    16651665+ *    HIFN_CRYPTO_BAD_INPUT  :  The passed in command had invalid settings. 
    16661666+ *    HIFN_CRYPTO_RINGS_FULL :  All DMA rings were full and non-blocking 
     
    24662466+               WRITE_REG_1(sc, HIFN_1_DMA_IER, sc->sc_dmaier); 
    24672467+#ifdef HIFN_VULCANDEV 
    2468 +               sc->sc_pkdev = make_dev(&vulcanpk_cdevsw, 0,  
     2468+               sc->sc_pkdev = make_dev(&vulcanpk_cdevsw, 0, 
    24692469+                                       UID_ROOT, GID_WHEEL, 0666, 
    24702470+                                       "vulcanpk"); 
     
    26652665+ * as enabling crypto twice will lock the board. 
    26662666+ */ 
    2667 +static int  
     2667+static int 
    26682668+hifn_enable_crypto(struct hifn_softc *sc) 
    26692669+{ 
     
    27572757+ * section of the HIFN Software Development reference manual. 
    27582758+ */ 
    2759 +static void  
     2759+static void 
    27602760+hifn_init_pci_registers(struct hifn_softc *sc) 
    27612761+{ 
     
    31423142+ * Initialize the descriptor rings. 
    31433143+ */ 
    3144 +static void  
     3144+static void 
    31453145+hifn_init_dma(struct hifn_softc *sc) 
    31463146+{ 
     
    34303430+       dma->srcu += src->nsegs; 
    34313431+       return (idx); 
    3432 +}  
    3433 + 
    3434 + 
    3435 +static int  
     3432+} 
     3433+ 
     3434+ 
     3435+static int 
    34363436+hifn_crypto( 
    34373437+       struct hifn_softc *sc, 
     
    43024302+               cmd->cry_masks |= HIFN_CRYPT_CMD_NEW_KEY; 
    43034303+ 
    4304 +               /*  
     4304+               /* 
    43054305+                * Need to specify the size for the AES key in the masks. 
    43064306+                */ 
     
    48594859+cryptoid_show(struct device *dev, 
    48604860+             struct device_attribute *attr, 
    4861 +             char *buf)                                                 
    4862 +{                                                               
    4863 +       struct hipp_softc *sc;                                   
     4861+             char *buf) 
     4862+{ 
     4863+       struct hipp_softc *sc; 
    48644864+ 
    48654865+       sc = pci_get_drvdata(to_pci_dev (dev)); 
     
    49934993+       if (sc->sc_irq != -1) 
    49944994+               free_irq(sc->sc_irq, sc); 
    4995 +        
     4995+ 
    49964996+#if 0 
    49974997+       if (sc->sc_dma) { 
     
    49994999+               WRITE_REG_1(sc, HIFN_1_DMA_CNFG, HIFN_DMACNFG_MSTRESET | 
    50005000+                           HIFN_DMACNFG_DMARESET | HIFN_DMACNFG_MODE); 
    5001 +                
     5001+ 
    50025002+               pci_free_consistent(sc->sc_pcidev, 
    50035003+                                   sizeof(*sc->sc_dma), 
     
    51525152+/* 
    51535153+ * Hifn HIPP-I/HIPP-II (7855/8155) driver. 
    5154 + * Copyright (c) 2006 Michael Richardson <mcr@xelerance.com> *  
     5154+ * Copyright (c) 2006 Michael Richardson <mcr@xelerance.com> * 
    51555155+ * 
    51565156+ * Redistribution and use in source and binary forms, with or without 
     
    53755375+       0,      0,      0,      0,      0,      0,      0,      0, 
    53765376+       0,      0,      0,      0,      0,      0,      0,      0, 
    5377 +       0,      0,      0,      0,      0,      0,      0,      0,       
     5377+       0,      0,      0,      0,      0,      0,      0,      0, 
    53785378+}; 
    53795379+ 
     
    54105410+                       md5_calc((u_int8_t *)(input + i), ctxt); 
    54115411+               } 
    5412 +                
     5412+ 
    54135413+               ctxt->md5_i = len - i; 
    54145414+               bcopy((void *)(input + i), (void *)ctxt->md5_buf, ctxt->md5_i); 
     
    54255425+       u_int gap; 
    54265426+ 
    5427 +       /* Don't count up padding. Keep md5_n. */        
     5427+       /* Don't count up padding. Keep md5_n. */ 
    54285428+       gap = MD5_BUFLEN - ctxt->md5_i; 
    54295429+       if (gap > 8) { 
     
    54415441+       } 
    54425442+ 
    5443 +       /* 8 byte word */        
     5443+       /* 8 byte word */ 
    54445444+#if BYTE_ORDER == LITTLE_ENDIAN 
    54455445+       bcopy(&ctxt->md5_n8[0], &ctxt->md5_buf[56], 8); 
     
    54895489+#if BYTE_ORDER == LITTLE_ENDIAN 
    54905490+       u_int32_t *X = (u_int32_t *)b64; 
    5491 +#endif  
     5491+#endif 
    54925492+#if BYTE_ORDER == BIG_ENDIAN 
    54935493+       /* 4 byte words */ 
     
    55215521+       ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14); 
    55225522+       ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16); 
    5523 +        
     5523+ 
    55245524+       ROUND2(A, B, C, D,  1, Se, 17); ROUND2(D, A, B, C,  6, Sf, 18); 
    55255525+       ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A,  0, Sh, 20); 
     
    55395539+       ROUND3(A, B, C, D,  9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46); 
    55405540+       ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A,  2, Sl, 48); 
    5541 +        
    5542 +       ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50);  
    5543 +       ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52);  
    5544 +       ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54);  
    5545 +       ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56);  
    5546 +       ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58);  
    5547 +       ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60);  
    5548 +       ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62);  
     5541+ 
     5542+       ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50); 
     5543+       ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52); 
     5544+       ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54); 
     5545+       ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56); 
     5546+       ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58); 
     5547+       ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60); 
     5548+       ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62); 
    55495549+       ROUND4(C, D, A, B,  2, So, 63); ROUND4(B, C, D, A,  9, Sp, 64); 
    55505550+ 
     
    60056005+               crypto_unblock(sc->sc_cid, wakeup); 
    60066006+       } 
    6007 +        
     6007+ 
    60086008+       return IRQ_HANDLED; 
    60096009+} 
     
    65416541+                * Tell the hardware to copy the header to the output. 
    65426542+                * The header is defined as the data from the end of 
    6543 +                * the bypass to the start of data to be encrypted.  
     6543+                * the bypass to the start of data to be encrypted. 
    65446544+                * Typically this is the inline IV.  Note that you need 
    65456545+                * to do this even if src+dst are the same; it appears 
     
    66406640+                                        * destination particle list that does 
    66416641+                                        * the necessary scatter DMA. 
    6642 +                                        */  
     6642+                                        */ 
    66436643+                                       safestats.st_iovnotuniform++; 
    66446644+                                       err = EINVAL; 
     
    67536753+       pci_unmap_operand(sc, &re->re_src); 
    67546754+ 
    6755 +       /*  
     6755+       /* 
    67566756+        * If result was written to a differet mbuf chain, swap 
    67576757+        * it in as the return value and reclaim the original. 
     
    68036803+                               re->re_sastate.sa_saved_indigest[0] = 
    68046804+                                       cpu_to_be32(re->re_sastate.sa_saved_indigest[0]); 
    6805 +                               re->re_sastate.sa_saved_indigest[1] =  
     6805+                               re->re_sastate.sa_saved_indigest[1] = 
    68066806+                                       cpu_to_be32(re->re_sastate.sa_saved_indigest[1]); 
    68076807+                               re->re_sastate.sa_saved_indigest[2] = 
     
    68106810+                               re->re_sastate.sa_saved_indigest[0] = 
    68116811+                                       cpu_to_le32(re->re_sastate.sa_saved_indigest[0]); 
    6812 +                               re->re_sastate.sa_saved_indigest[1] =  
     6812+                               re->re_sastate.sa_saved_indigest[1] = 
    68136813+                                       cpu_to_le32(re->re_sastate.sa_saved_indigest[1]); 
    68146814+                               re->re_sastate.sa_saved_indigest[2] = 
     
    68526852+        * the data register until it changes from the first read. 
    68536853+        * Once it changes read the data register until it changes 
    6854 +        * again.  At this time the RNG is considered initialized.  
     6854+        * again.  At this time the RNG is considered initialized. 
    68556855+        * This could take between 750ms - 1000ms in time. 
    68566856+        */ 
     
    68906890+       DPRINTF(("%s()\n", __FUNCTION__)); 
    68916891+ 
    6892 +       WRITE_REG(sc, SAFE_RNG_CTRL,  
     6892+       WRITE_REG(sc, SAFE_RNG_CTRL, 
    68936893+               READ_REG(sc, SAFE_RNG_CTRL) | SAFE_RNG_CTRL_SHORTEN); 
    68946894+} 
     
    69126912+ 
    69136913+       DPRINTF(("%s()\n", __FUNCTION__)); 
    6914 +        
     6914+ 
    69156915+       safestats.st_rng++; 
    69166916+       /* 
     
    71327132+ 
    71337133+       crp = (struct cryptop *)re->re_crp; 
    7134 +        
     7134+ 
    71357135+       re->re_desc.d_csr = 0; 
    7136 +        
     7136+ 
    71377137+       crp->crp_etype = EFAULT; 
    71387138+       crypto_done(crp); 
     
    72967296+               modp = krp->krp_param[SAFE_CRK_PARAM_MOD].crp_p + 
    72977297+                   ((mod_bits + 7) / 8) - 1; 
    7298 +                
     7298+ 
    72997299+               for (i = 0; i < (mod_bits + 7) / 8; i++, basep--, modp--) { 
    73007300+                       if (*modp < *basep) 
     
    86968696+#define        SAFE_SA_CMD1_AES256     0x04000000      /* 256-bit AES key */ 
    86978697+ 
    8698 +/*  
     8698+/* 
    86998699+ * Security Associate State Record (Rev 1). 
    87008700+ */ 
     
    1064310643+       /* XXX flush queues??? */ 
    1064410644+ 
    10645 +       /*  
     10645+       /* 
    1064610646+        * Reclaim dynamically allocated resources. 
    1064710647+        */ 
     
    1100211002+ * internal bus, and runs asynchronous to the processor core.  It has 
    1100311003+ * a wide gamut of cryptographic acceleration features, including single- 
    11004 + * pass IPsec (also known as algorithm chaining).  To properly utilize  
    11005 + * all of the SEC's performance enhancing features, further reworking  
     11004+ * pass IPsec (also known as algorithm chaining).  To properly utilize 
     11005+ * all of the SEC's performance enhancing features, further reworking 
    1100611006+ * of higher level code (framework, applications) will be necessary. 
    1100711007+ * 
    1100811008+ * The following table shows which SEC version is present in which devices: 
    11009 + *  
     11009+ * 
    1101011010+ * Devices       SEC version 
    1101111011+ * 
     
    1105111051+ * Channel ch0 may drive an aes operation to the aes unit (AESU), 
    1105211052+ * and, at the same time, ch1 may drive a message digest operation 
    11053 + * to the mdeu. Each channel has an input descriptor FIFO, and the  
     11053+ * to the mdeu. Each channel has an input descriptor FIFO, and the 
    1105411054+ * FIFO can contain, e.g. on the 8541E, up to 24 entries, before a 
    1105511055+ * a buffer overrun error is triggered. The controller is responsible 
    11056 + * for fetching the data from descriptor pointers, and passing the  
    11057 + * data to the appropriate EUs. The controller also writes the  
    11058 + * cryptographic operation's result to memory. The SEC notifies  
    11059 + * completion by triggering an interrupt and/or setting the 1st byte  
     11056+ * for fetching the data from descriptor pointers, and passing the 
     11057+ * data to the appropriate EUs. The controller also writes the 
     11058+ * cryptographic operation's result to memory. The SEC notifies 
     11059+ * completion by triggering an interrupt and/or setting the 1st byte 
    1106011060+ * of the hdr field to 0xff. 
    1106111061+ * 
     
    1109411094+#include <uio.h> 
    1109511095+ 
    11096 +#define DRV_NAME "talitos"  
     11096+#define DRV_NAME "talitos" 
    1109711097+ 
    1109811098+#include "talitos_dev.h" 
     
    1110911109+static int talitos_process(device_t dev, struct cryptop *crp, int hint); 
    1111011110+static void dump_talitos_status(struct talitos_softc *sc); 
    11111 +static int talitos_submit(struct talitos_softc *sc, struct talitos_desc *td,  
     11111+static int talitos_submit(struct talitos_softc *sc, struct talitos_desc *td, 
    1111211112+                                                               int chsel); 
    1111311113+static void talitos_doneprocessing(struct talitos_softc *sc); 
     
    1116711167+       printk(KERN_INFO "%s: ISR          0x%08x_%08x\n", 
    1116811168+                       device_get_nameunit(sc->sc_cdev), v, v_hi); 
    11169 +       for (i = 0; i < sc->sc_num_channels; i++) {  
    11170 +               v = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET +  
     11169+       for (i = 0; i < sc->sc_num_channels; i++) { 
     11170+               v = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET + 
    1117111171+                       TALITOS_CH_CDPR); 
    11172 +               v_hi = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET +  
     11172+               v_hi = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET + 
    1117311173+                       TALITOS_CH_CDPR_HI); 
    11174 +               printk(KERN_INFO "%s: CDPR     ch%d 0x%08x_%08x\n",  
     11174+               printk(KERN_INFO "%s: CDPR     ch%d 0x%08x_%08x\n", 
    1117511175+                               device_get_nameunit(sc->sc_cdev), i, v, v_hi); 
    1117611176+       } 
    11177 +       for (i = 0; i < sc->sc_num_channels; i++) {  
    11178 +               v = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET +  
     11177+       for (i = 0; i < sc->sc_num_channels; i++) { 
     11178+               v = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET + 
    1117911179+                       TALITOS_CH_CCPSR); 
    11180 +               v_hi = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET +  
     11180+               v_hi = talitos_read(sc->sc_base_addr + i*TALITOS_CH_OFFSET + 
    1118111181+                       TALITOS_CH_CCPSR_HI); 
    11182 +               printk(KERN_INFO "%s: CCPSR    ch%d 0x%08x_%08x\n",  
     11182+               printk(KERN_INFO "%s: CCPSR    ch%d 0x%08x_%08x\n", 
    1118311183+                               device_get_nameunit(sc->sc_cdev), i, v, v_hi); 
    1118411184+       } 
    1118511185+       ptr = sc->sc_base_addr + TALITOS_CH_DESCBUF; 
    11186 +       for (i = 0; i < 16; i++) {  
     11186+       for (i = 0; i < 16; i++) { 
    1118711187+               v = talitos_read(ptr++); v_hi = talitos_read(ptr++); 
    11188 +               printk(KERN_INFO "%s: DESCBUF  ch0 0x%08x_%08x (tdp%02d)\n",  
     11188+               printk(KERN_INFO "%s: DESCBUF  ch0 0x%08x_%08x (tdp%02d)\n", 
    1118911189+                               device_get_nameunit(sc->sc_cdev), v, v_hi, i); 
    1119011190+       } 
     
    1119411194+ 
    1119511195+#ifdef CONFIG_OCF_RANDOMHARVEST 
    11196 +/*  
     11196+/* 
    1119711197+ * pull random numbers off the RNG FIFO, not exceeding amount available 
    1119811198+ */ 
     
    1121411214+       } 
    1121511215+       /* 
    11216 +        * OFL is number of available 64-bit words,  
     11216+        * OFL is number of available 64-bit words, 
    1121711217+        * shift and convert to a 32-bit word count 
    1121811218+        */ 
     
    1122211222+               maxwords = v; 
    1122311223+       for (rc = 0; rc < maxwords; rc++) { 
    11224 +               buf[rc] = talitos_read(sc->sc_base_addr +  
     11224+               buf[rc] = talitos_read(sc->sc_base_addr + 
    1122511225+                       TALITOS_RNG_FIFO + rc*sizeof(u_int32_t)); 
    1122611226+       } 
    1122711227+       if (maxwords & 1) { 
    11228 +               /*  
     11228+               /* 
    1122911229+                * RNG will complain with an AE in the RNGISR 
    1123011230+                * if we don't complete the pairs of 32-bit reads 
    1123111231+                * to its 64-bit register based FIFO 
    1123211232+                */ 
    11233 +               v = talitos_read(sc->sc_base_addr +  
     11233+               v = talitos_read(sc->sc_base_addr + 
    1123411234+                       TALITOS_RNG_FIFO + rc*sizeof(u_int32_t)); 
    1123511235+       } 
     
    1124811248+       v |= TALITOS_RNGRCR_HI_SR; 
    1124911249+       talitos_write(sc->sc_base_addr + TALITOS_RNGRCR_HI, v); 
    11250 +       while ((talitos_read(sc->sc_base_addr + TALITOS_RNGSR_HI)  
     11250+       while ((talitos_read(sc->sc_base_addr + TALITOS_RNGSR_HI) 
    1125111251+               & TALITOS_RNGSR_HI_RD) == 0) 
    1125211252+                       cpu_relax(); 
    1125311253+       /* 
    1125411254+        * we tell the RNG to start filling the RNG FIFO 
    11255 +        * by writing the RNGDSR  
     11255+        * by writing the RNGDSR 
    1125611256+        */ 
    1125711257+       v = talitos_read(sc->sc_base_addr + TALITOS_RNGDSR_HI); 
    1125811258+       talitos_write(sc->sc_base_addr + TALITOS_RNGDSR_HI, v); 
    1125911259+       /* 
    11260 +        * 64 bits of data will be pushed onto the FIFO every  
    11261 +        * 256 SEC cycles until the FIFO is full.  The RNG then  
     11260+        * 64 bits of data will be pushed onto the FIFO every 
     11261+        * 256 SEC cycles until the FIFO is full.  The RNG then 
    1126211262+        * attempts to keep the FIFO full. 
    1126311263+        */ 
     
    1126911269+       } 
    1127011270+       /* 
    11271 +        * n.b. we need to add a FIPS test here - if the RNG is going  
     11271+        * n.b. we need to add a FIPS test here - if the RNG is going 
    1127211272+        * to fail, it's going to fail at reset time 
    1127311273+        */ 
     
    1131511315+       if (encini == NULL && macini == NULL) 
    1131611316+               return EINVAL; 
    11317 +       if (encini) {    
     11317+       if (encini) { 
    1131811318+               /* validate key length */ 
    1131911319+               switch (encini->cri_alg) { 
     
    1133411334+                       break; 
    1133511335+               default: 
    11336 +                       DPRINTF("UNKNOWN encini->cri_alg %d\n",  
     11336+                       DPRINTF("UNKNOWN encini->cri_alg %d\n", 
    1133711337+                               encini->cri_alg); 
    1133811338+                       return EINVAL; 
     
    1136011360+                       sesn = sc->sc_nsessions; 
    1136111361+                       ses = (struct talitos_session *) kmalloc( 
    11362 +                               (sesn + 1) * sizeof(struct talitos_session),  
     11362+                               (sesn + 1) * sizeof(struct talitos_session), 
    1136311363+                               SLAB_ATOMIC); 
    1136411364+                       if (ses == NULL) 
     
    1136611366+                       memset(ses, 0, 
    1136711367+                               (sesn + 1) * sizeof(struct talitos_session)); 
    11368 +                       memcpy(ses, sc->sc_sessions,  
     11368+                       memcpy(ses, sc->sc_sessions, 
    1136911369+                               sesn * sizeof(struct talitos_session)); 
    1137011370+                       memset(sc->sc_sessions, 0, 
     
    1140911409+       } 
    1141011410+ 
    11411 +       /* really should make up a template td here,  
     11411+       /* really should make up a template td here, 
    1141211412+        * and only fill things like i/o and direction in process() */ 
    1141311413+ 
     
    1144011440+ 
    1144111441+/* 
    11442 + * launch device processing - it will come back with done notification  
    11443 + * in the form of an interrupt and/or HDR_DONE_BITS in header  
    11444 + */ 
    11445 +static int  
     11442+ * launch device processing - it will come back with done notification 
     11443+ * in the form of an interrupt and/or HDR_DONE_BITS in header 
     11444+ */ 
     11445+static int 
    1144611446+talitos_submit( 
    1144711447+       struct talitos_softc *sc, 
     
    1145211452+ 
    1145311453+       v = dma_map_single(NULL, td, sizeof(*td), DMA_TO_DEVICE); 
    11454 +       talitos_write(sc->sc_base_addr +  
     11454+       talitos_write(sc->sc_base_addr + 
    1145511455+               chsel*TALITOS_CH_OFFSET + TALITOS_CH_FF, 0); 
    11456 +       talitos_write(sc->sc_base_addr +  
     11456+       talitos_write(sc->sc_base_addr + 
    1145711457+               chsel*TALITOS_CH_OFFSET + TALITOS_CH_FF_HI, v); 
    1145811458+       return 0; 
     
    1147011470+       unsigned long flags; 
    1147111471+       /* descriptor mappings */ 
    11472 +       int hmac_key, hmac_data, cipher_iv, cipher_key,  
     11472+       int hmac_key, hmac_data, cipher_iv, cipher_key, 
    1147311473+               in_fifo, out_fifo, cipher_iv_out; 
    1147411474+       static int chsel = -1; 
     
    1148611486+       ses = &sc->sc_sessions[TALITOS_SESSION(crp->crp_sid)]; 
    1148711487+ 
    11488 +        /* enter the channel scheduler */  
     11488+        /* enter the channel scheduler */ 
    1148911489+       spin_lock_irqsave(&sc->sc_chnfifolock[sc->sc_num_channels], flags); 
    1149011490+ 
     
    1149811498+                * haven't seen this algo the last sc_num_channels or more 
    1149911499+                * use round robin in this case 
    11500 +                * nb: sc->sc_num_channels must be power of 2  
     11500+                * nb: sc->sc_num_channels must be power of 2 
    1150111501+                */ 
    1150211502+               chsel = (chsel + 1) & (sc->sc_num_channels - 1); 
    1150311503+       } else { 
    1150411504+               /* 
    11505 +                * matches channel with same target execution unit;  
     11505+                * matches channel with same target execution unit; 
    1150611506+                * use same channel in this case 
    1150711507+                */ 
     
    1151011510+       sc->sc_chnlastalg[chsel] = crp->crp_desc->crd_alg; 
    1151111511+ 
    11512 +        /* release the channel scheduler lock */  
     11512+        /* release the channel scheduler lock */ 
    1151311513+       spin_unlock_irqrestore(&sc->sc_chnfifolock[sc->sc_num_channels], flags); 
    1151411514+ 
     
    1151911519+       for (i = 0; i < sc->sc_chfifo_len; i++) { 
    1152011520+               if (sc->sc_chnfifo[chsel][i].cf_desc.hdr == 0) { 
    11521 +                       /*  
     11521+                       /* 
    1152211522+                        * ensure correct descriptor formation by 
    1152311523+                        * avoiding inadvertently setting "optional" entries 
     
    1152711527+                               0, sizeof(*td)); 
    1152811528+                       /* reserve it with done notification request bit */ 
    11529 +                       sc->sc_chnfifo[chsel][i].cf_desc.hdr |=  
     11529+                       sc->sc_chnfifo[chsel][i].cf_desc.hdr |= 
    1153011530+                               TALITOS_DONE_NOTIFY; 
    1153111531+                       break; 
     
    1153911539+               goto errout; 
    1154011540+       } 
    11541 +        
     11541+ 
    1154211542+       td = &sc->sc_chnfifo[chsel][i].cf_desc; 
    1154311543+       sc->sc_chnfifo[chsel][i].cf_crp = crp; 
     
    1163411634+                       goto errout; 
    1163511635+               } 
    11636 +               td->ptr[in_fifo].ptr = dma_map_single(NULL, skb->data,  
     11636+               td->ptr[in_fifo].ptr = dma_map_single(NULL, skb->data, 
    1163711637+                       skb->len, DMA_TO_DEVICE); 
    1163811638+               td->ptr[in_fifo].len = skb->len; 
    11639 +               td->ptr[out_fifo].ptr = dma_map_single(NULL, skb->data,  
     11639+               td->ptr[out_fifo].ptr = dma_map_single(NULL, skb->data, 
    1164011640+                       skb->len, DMA_TO_DEVICE); 
    1164111641+               td->ptr[out_fifo].len = skb->len; 
     
    1171011710+                */ 
    1171111711+               if (enccrd->crd_flags & CRD_F_ENCRYPT) { 
    11712 +                       td->hdr |= TALITOS_DIR_OUTBOUND;  
     11712+                       td->hdr |= TALITOS_DIR_OUTBOUND; 
    1171311713+                       if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) 
    1171411714+                               iv = enccrd->crd_iv; 
     
    1172011720+                       } 
    1172111721+               } else { 
    11722 +                       td->hdr |= TALITOS_DIR_INBOUND;  
     11722+                       td->hdr |= TALITOS_DIR_INBOUND; 
    1172311723+                       if (enccrd->crd_flags & CRD_F_IV_EXPLICIT) { 
    1172411724+                               iv = enccrd->crd_iv; 
     
    1173011730+                       } 
    1173111731+               } 
    11732 +               td->ptr[cipher_iv].ptr = dma_map_single(NULL, iv, ivsize,  
     11732+               td->ptr[cipher_iv].ptr = dma_map_single(NULL, iv, ivsize, 
    1173311733+                       DMA_TO_DEVICE); 
    1173411734+               td->ptr[cipher_iv].len = ivsize; 
     
    1174811748+                       |  TALITOS_MODE1_MDEU_PAD; 
    1174911749+               switch (maccrd->crd_alg) { 
    11750 +                       case    CRYPTO_MD5:      
     11750+                       case    CRYPTO_MD5: 
    1175111751+                               td->hdr |= TALITOS_MODE1_MDEU_MD5; 
    1175211752+                               break; 
    11753 +                       case    CRYPTO_MD5_HMAC:         
     11753+                       case    CRYPTO_MD5_HMAC: 
    1175411754+                               td->hdr |= TALITOS_MODE1_MDEU_MD5_HMAC; 
    1175511755+                               break; 
    11756 +                       case    CRYPTO_SHA1:     
     11756+                       case    CRYPTO_SHA1: 
    1175711757+                               td->hdr |= TALITOS_MODE1_MDEU_SHA1; 
    1175811758+                               break; 
    11759 +                       case    CRYPTO_SHA1_HMAC:        
     11759+                       case    CRYPTO_SHA1_HMAC: 
    1176011760+                               td->hdr |= TALITOS_MODE1_MDEU_SHA1_HMAC; 
    1176111761+                               break; 
     
    1177411774+                        */ 
    1177511775+                       /* ipsec only for now */ 
    11776 +                       td->ptr[hmac_key].ptr = dma_map_single(NULL,  
     11776+                       td->ptr[hmac_key].ptr = dma_map_single(NULL, 
    1177711777+                               ses->ses_hmac, ses->ses_hmac_len, DMA_TO_DEVICE); 
    1177811778+                       td->ptr[hmac_key].len = ses->ses_hmac_len; 
     
    1178311783+                       /* bytes of HMAC to postpend to ciphertext */ 
    1178411784+                       td->ptr[out_fifo].extent =  ses->ses_mlen; 
    11785 +                       td->ptr[hmac_data].ptr += maccrd->crd_skip;  
     11785+                       td->ptr[hmac_data].ptr += maccrd->crd_skip; 
    1178611786+                       td->ptr[hmac_data].len = enccrd->crd_skip - maccrd->crd_skip; 
    1178711787+               } 
     
    1179711797+                               |  TALITOS_MODE0_MDEU_PAD; 
    1179811798+               switch (maccrd->crd_alg) { 
    11799 +                       case    CRYPTO_MD5:      
     11799+                       case    CRYPTO_MD5: 
    1180011800+                               td->hdr |= TALITOS_MODE0_MDEU_MD5; 
    1180111801+                               DPRINTF("MD5  ses %d ch %d len %d\n", 
    11802 +                                       (u32)TALITOS_SESSION(crp->crp_sid),  
     11802+                                       (u32)TALITOS_SESSION(crp->crp_sid), 
    1180311803+                                       chsel, td->ptr[in_fifo].len); 
    1180411804+                               break; 
    11805 +                       case    CRYPTO_MD5_HMAC:         
     11805+                       case    CRYPTO_MD5_HMAC: 
    1180611806+                               td->hdr |= TALITOS_MODE0_MDEU_MD5_HMAC; 
    1180711807+                               break; 
    11808 +                       case    CRYPTO_SHA1:     
     11808+                       case    CRYPTO_SHA1: 
    1180911809+                               td->hdr |= TALITOS_MODE0_MDEU_SHA1; 
    1181011810+                               DPRINTF("SHA1 ses %d ch %d len %d\n", 
    11811 +                                       (u32)TALITOS_SESSION(crp->crp_sid),  
     11811+                                       (u32)TALITOS_SESSION(crp->crp_sid), 
    1181211812+                                       chsel, td->ptr[in_fifo].len); 
    1181311813+                               break; 
    11814 +                       case    CRYPTO_SHA1_HMAC:        
     11814+                       case    CRYPTO_SHA1_HMAC: 
    1181511815+                               td->hdr |= TALITOS_MODE0_MDEU_SHA1_HMAC; 
    1181611816+                               break; 
     
    1182711827+               if ((maccrd->crd_alg == CRYPTO_MD5_HMAC) || 
    1182811828+                  (maccrd->crd_alg == CRYPTO_SHA1_HMAC)) { 
    11829 +                       td->ptr[hmac_key].ptr = dma_map_single(NULL,  
    11830 +                               ses->ses_hmac, ses->ses_hmac_len,  
     11829+                       td->ptr[hmac_key].ptr = dma_map_single(NULL, 
     11830+                               ses->ses_hmac, ses->ses_hmac_len, 
    1183111831+                               DMA_TO_DEVICE); 
    1183211832+                       td->ptr[hmac_key].len = ses->ses_hmac_len; 
    1183311833+               } 
    11834 +       }  
     11834+       } 
    1183511835+       else { 
    1183611836+               /* using process key (session data has duplicate) */ 
    11837 +               td->ptr[cipher_key].ptr = dma_map_single(NULL,  
    11838 +                       enccrd->crd_key, (enccrd->crd_klen + 7) / 8,  
     11837+               td->ptr[cipher_key].ptr = dma_map_single(NULL, 
     11838+                       enccrd->crd_key, (enccrd->crd_klen + 7) / 8, 
    1183911839+                       DMA_TO_DEVICE); 
    1184011840+               td->ptr[cipher_key].len = (enccrd->crd_klen + 7) / 8; 
     
    1185111851+} 
    1185211852+ 
    11853 +/* go through all channels descriptors, notifying OCF what has  
    11854 + * _and_hasn't_ successfully completed and reset the device  
     11853+/* go through all channels descriptors, notifying OCF what has 
     11854+ * _and_hasn't_ successfully completed and reset the device 
    1185511855+ * (otherwise it's up to decoding desc hdrs!) 
    1185611856+ */ 
     
    1186411864+ 
    1186511865+       if (debug) dump_talitos_status(sc); 
    11866 +       /* go through descriptors, try and salvage those successfully done,  
     11866+       /* go through descriptors, try and salvage those successfully done, 
    1186711867+        * and EIO those that weren't 
    1186811868+        */ 
     
    1187111871+               for (j = 0; j < sc->sc_chfifo_len; j++) { 
    1187211872+                       if (sc->sc_chnfifo[i][j].cf_desc.hdr) { 
    11873 +                               if ((sc->sc_chnfifo[i][j].cf_desc.hdr  
    11874 +                                       & TALITOS_HDR_DONE_BITS)  
     11873+                               if ((sc->sc_chnfifo[i][j].cf_desc.hdr 
     11874+                                       & TALITOS_HDR_DONE_BITS) 
    1187511875+                                       != TALITOS_HDR_DONE_BITS) { 
    1187611876+                                       /* this one didn't finish */ 
    1187711877+                                       /* signify in crp->etype */ 
    11878 +                                       sc->sc_chnfifo[i][j].cf_crp->crp_etype  
     11878+                                       sc->sc_chnfifo[i][j].cf_crp->crp_etype 
    1187911879+                                               = EIO; 
    1188011880+                               } 
     
    1191911919+               for (j = 0; j < sc->sc_chfifo_len; j++) { 
    1192011920+                       /* descriptor has done bits set? */ 
    11921 +                       if ((sc->sc_chnfifo[i][j].cf_desc.hdr  
    11922 +                               & TALITOS_HDR_DONE_BITS)  
     11921+                       if ((sc->sc_chnfifo[i][j].cf_desc.hdr 
     11922+                               & TALITOS_HDR_DONE_BITS) 
    1192311923+                               == TALITOS_HDR_DONE_BITS) { 
    1192411924+                               /* notify ocf */ 
     
    1194811948+       struct talitos_softc *sc = arg; 
    1194911949+       u_int32_t v, v_hi; 
    11950 +        
     11950+ 
    1195111951+       /* ack */ 
    1195211952+       v = talitos_read(sc->sc_base_addr + TALITOS_ISR); 
     
    1198011980+       /* init all channels */ 
    1198111981+       for (i = 0; i < sc->sc_num_channels; i++) { 
    11982 +               v = talitos_read(sc->sc_base_addr +  
     11982+               v = talitos_read(sc->sc_base_addr + 
    1198311983+                       i*TALITOS_CH_OFFSET + TALITOS_CH_CCCR_HI); 
    1198411984+               v |= TALITOS_CH_CCCR_HI_CDWE 
    1198511985+                 |  TALITOS_CH_CCCR_HI_CDIE;  /* invoke interrupt if done */ 
    11986 +               talitos_write(sc->sc_base_addr +  
     11986+               talitos_write(sc->sc_base_addr + 
    1198711987+                       i*TALITOS_CH_OFFSET + TALITOS_CH_CCCR_HI, v); 
    1198811988+       } 
     
    1202912029+       /* 
    1203012030+        * Master reset 
    12031 +        * errata documentation: warning: certain SEC interrupts  
    12032 +        * are not fully cleared by writing the MCR:SWR bit,  
    12033 +        * set bit twice to completely reset  
     12031+        * errata documentation: warning: certain SEC interrupts 
     12032+        * are not fully cleared by writing the MCR:SWR bit, 
     12033+        * set bit twice to completely reset 
    1203412034+        */ 
    1203512035+       talitos_reset_device_master(sc);        /* once */ 
    1203612036+       talitos_reset_device_master(sc);        /* and once again */ 
    12037 +        
     12037+ 
    1203812038+       /* reset all channels */ 
    1203912039+       for (i = 0; i < sc->sc_num_channels; i++) { 
     
    1210512105+                       device_get_nameunit(sc->sc_cdev), sc); 
    1210612106+       if (rc) { 
    12107 +               printk(KERN_ERR "%s: failed to hook irq %d\n",  
     12107+               printk(KERN_ERR "%s: failed to hook irq %d\n", 
    1210812108+                               device_get_nameunit(sc->sc_cdev), sc->sc_irq); 
    1210912109+               sc->sc_irq = -1; 
     
    1216712167+ 
    1216812168+       sc->sc_chnfifo = (struct desc_cryptop_pair **) kmalloc( 
    12169 +               sc->sc_num_channels * sizeof(struct desc_cryptop_pair *),  
     12169+               sc->sc_num_channels * sizeof(struct desc_cryptop_pair *), 
    1217012170+               GFP_KERNEL); 
    1217112171+       if (!sc->sc_chnfifo) 
     
    1217312173+       for (i = 0; i < sc->sc_num_channels; i++) { 
    1217412174+               sc->sc_chnfifo[i] = (struct desc_cryptop_pair *) kmalloc( 
    12175 +                       sc->sc_chfifo_len * sizeof(struct desc_cryptop_pair),  
     12175+                       sc->sc_chfifo_len * sizeof(struct desc_cryptop_pair), 
    1217612176+                       GFP_KERNEL); 
    1217712177+               if (!sc->sc_chnfifo[i]) 
    1217812178+                       goto out; 
    12179 +               memset(sc->sc_chnfifo[i], 0,  
     12179+               memset(sc->sc_chnfifo[i], 0, 
    1218012180+                       sc->sc_chfifo_len * sizeof(struct desc_cryptop_pair)); 
    1218112181+       } 
     
    1243712437+ 
    1243812438+/* 
    12439 + * following num_channels, channel-fifo-depth, exec-unit-mask, and  
     12439+ * following num_channels, channel-fifo-depth, exec-unit-mask, and 
    1244012440+ * descriptor-types-mask are for forward-compatibility with openfirmware 
    1244112441+ * flat device trees 
     
    1246512465+#define TALITOS_CHFIFOLEN_SEC_2_4      24 
    1246612466+ 
    12467 +/*  
     12467+/* 
    1246812468+ *  exec-unit-mask : The bitmask representing what Execution Units (EUs) 
    12469 + *  are available. EU information should be encoded following the SEC's  
     12469+ *  are available. EU information should be encoded following the SEC's 
    1247012470+ *  EU_SEL0 bitfield documentation, i.e. as follows: 
    12471 + *  
     12471+ * 
    1247212472+ *    bit 31 = set if SEC permits no-EU selection (should be always set) 
    1247312473+ *    bit 30 = set if SEC has the ARC4 EU (AFEU) 
     
    1247812478+ *    bit 25 = set if SEC has the aes EU (AESU) 
    1247912479+ *    bit 24 = set if SEC has the Kasumi EU (KEU) 
    12480 + *  
     12480+ * 
    1248112481+ */ 
    1248212482+#define TALITOS_HAS_EU_NONE            (1<<0) 
     
    1249912499+/* 
    1250012500+ *  descriptor-types-mask : The bitmask representing what descriptors 
    12501 + *  are available. Descriptor type information should be encoded  
    12502 + *  following the SEC's Descriptor Header Dword DESC_TYPE field  
     12501+ *  are available. Descriptor type information should be encoded 
     12502+ *  following the SEC's Descriptor Header Dword DESC_TYPE field 
    1250312503+ *  documentation, i.e. as follows: 
    1250412504+ * 
     
    1252612526+#define TALITOS_HAS_DESCTYPES_SEC_2_1  0x012b0ebf 
    1252712527+ 
    12528 +/*  
     12528+/* 
    1252912529+ * a TALITOS_xxx_HI address points to the low data bits (32-63) of the register 
    1253012530+ */ 
     
    1256512565+#define TALITOS_CH_CDPR                0x1140  /* Crypto-Channel Pointer Status Reg */ 
    1256612566+#define TALITOS_CH_CDPR_HI     0x1144  /* Crypto-Channel Pointer Status Reg */ 
    12567 +#define TALITOS_CH_DESCBUF     0x1180  /* (thru 11bf) Crypto-Channel  
     12567+#define TALITOS_CH_DESCBUF     0x1180  /* (thru 11bf) Crypto-Channel 
    1256812568+                                        * Descriptor Buffer (debug) */ 
    1256912569+ 
     
    1298712987+               } 
    1298812988+       } 
    12989 +        
     12989+ 
    1299012990+       kfree(buf); 
    1299112991+ 
     
    1396413964+                       ((IX_MBUF_MLEN(&q->ixp_q_mbuf) * 8) + 72 + 511) / 8; 
    1396513965+               tbuf = kmalloc(IX_MBUF_MLEN(&q->ixp_q_mbuf), SLAB_ATOMIC); 
    13966 +                
     13966+ 
    1396713967+               if (IX_MBUF_MDATA(&q->ixp_q_mbuf) == NULL) { 
    1396813968+                       printk("ixp: kmalloc(%u, SLAB_ATOMIC) failed\n", 
     
    1453114531+                               ixp_kperform_cb, 
    1453214532+                               &q->pkq_result); 
    14533 +        
     14533+ 
    1453414534+               if (status == IX_CRYPTO_ACC_STATUS_SUCCESS) { 
    1453514535+                       dprintk("%s() - ixCryptoAccPkeEauPerform SUCCESS\n", __FUNCTION__); 
     
    1490814908+       int typ = crid & (CRYPTOCAP_F_SOFTWARE | CRYPTOCAP_F_HARDWARE); 
    1490914909+       int caps = 0; 
    14910 +        
     14910+ 
    1491114911+       /* if the user hasn't selected a driver, then just call newsession */ 
    1491214912+       if (hid == 0 && typ != 0) 
     
    1492014920+               return EINVAL; 
    1492114921+       } 
    14922 +        
     14922+ 
    1492314923+       /* the user didn't specify SW or HW, so the driver is ok */ 
    1492414924+       if (typ == 0) 
     
    1525715257+ 
    1525815258+       dprintk("%s finished WAITING error=%d\n", __FUNCTION__, error); 
    15259 +        
     15259+ 
    1526015260+       kop->crk_crid = krp->krp_crid;          /* device that did the work */ 
    1526115261+       if (krp->krp_status != 0) { 
     
    1533115331+       return (0); 
    1533215332+} 
    15333 +        
     15333+ 
    1533415334+static struct csession * 
    1533515335+cseadd(struct fcrypt *fcr, struct csession *cse) 
     
    1600916009+       caddr_t         mackey; 
    1601016010+ 
    16011 +       u_int32_t       ses;            /* returns: session # */  
     16011+       u_int32_t       ses;            /* returns: session # */ 
    1601216012+}; 
    1601316013+ 
     
    1602116021+       caddr_t         mackey; 
    1602216022+ 
    16023 +       u_int32_t       ses;            /* returns: session # */  
     16023+       u_int32_t       ses;            /* returns: session # */ 
    1602416024+       int             crid;           /* driver id + flags (rw) */ 
    1602516025+       int             pad[4];         /* for future expansion */ 
     
    1631116311+ * 
    1631216312+ * Written by David McCullough <david_mccullough@securecomputing.com> 
    16313 + * Copyright (C) 2006-2007 David McCullough  
     16313+ * Copyright (C) 2006-2007 David McCullough 
    1631416314+ * 
    1631516315+ * LICENSE TERMS 
     
    1708817088+                                       sg_len += len; 
    1708917089+                                       skip = 0; 
    17090 +                               } else  
     17090+                               } else 
    1709117091+                                       skip -= uiop->uio_iov[sg_num].iov_len; 
    1709217092+                       } 
     
    1710517105+                       unsigned char iv[EALG_MAX_BLOCK_LEN]; 
    1710617106+                       unsigned char *ivp = iv; 
    17107 +                       int ivsize =  
     17107+                       int ivsize = 
    1710817108+                               crypto_blkcipher_ivsize(crypto_blkcipher_cast(sw->sw_tfm)); 
    1710917109+                       struct blkcipher_desc desc; 
     
    1720617206+                               crypto_hash_digest(&desc, sg, sg_len, result); 
    1720717207+#endif /* #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) */ 
    17208 +                                
     17208+ 
    1720917209+                       } else { /* SW_TYPE_HASH */ 
    1721017210+                               crypto_hash_digest(&desc, sg, sg_len, result); 
     
    1731517315+       for (i = CRYPTO_ALGORITHM_MIN; i <= CRYPTO_ALGORITHM_MAX; ++i) 
    1731617316+       { 
    17317 +                
     17317+ 
    1731817318+               algo = crypto_details[i].alg_name; 
    1731917319+               if (!algo || !*algo) 
Note: See TracChangeset for help on using the changeset viewer.