1. 02 9月, 2012 1 次提交
    • D
      sparc64: Fix bugs in unrolled 256-bit loops. · 699871bc
      David S. Miller 提交于
      Some dm-crypt testing revealed several bugs in the 256-bit unrolled
      loops.
      
      The DECRYPT_256_2() macro had two errors:
      
      1) Missing reload of KEY registers %f60 and %f62
      
      2) Missing "\" in penultimate line of definition.
      
      In aes_sparc64_ecb_decrypt_256, we were storing the second half of the
      encryption result from the wrong source registers.
      
      In aes_sparc64_ctr_crypt_256 we have to be careful when we fall out of
      the 32-byte-at-a-time loop and handle a trailing 16-byte chunk.  In
      that case we've clobbered the final key holding registers and have to
      restore them before executing the ENCRYPT_256() macro.  Inside of the
      32-byte-at-a-time loop things are OK, because we do this key register
      restoring during the first few rounds of the ENCRYPT_256_2() macro.
      Signed-off-by: NDavid S. Miller <davem@davemloft.net>
      699871bc
  2. 01 9月, 2012 1 次提交
  3. 30 8月, 2012 5 次提交
    • D
      sparc64: Unroll CTR crypt loops in AES driver. · 4e71bb49
      David S. Miller 提交于
      Before:
      
      testing speed of ctr(aes) encryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 206 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 244 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 360 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 814 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 5021 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 206 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 240 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 378 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 939 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 6395 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 209 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 249 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 414 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 1073 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 7110 cycles (8192 bytes)
      
      testing speed of ctr(aes) decryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 225 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 233 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 344 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 810 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 5021 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 206 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 240 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 376 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 938 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 6380 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 214 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 251 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 411 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 1070 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 7114 cycles (8192 bytes)
      
      After:
      
      testing speed of ctr(aes) encryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 211 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 246 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 344 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 799 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 4975 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 210 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 236 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 365 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 888 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 6055 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 209 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 255 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 404 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 1010 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 6669 cycles (8192 bytes)
      
      testing speed of ctr(aes) decryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 210 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 233 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 340 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 818 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 4956 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 206 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 239 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 361 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 888 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 5996 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 214 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 248 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 395 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 1010 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 6664 cycles (8192 bytes)
      Signed-off-by: NDavid S. Miller <davem@davemloft.net>
      4e71bb49
    • D
      sparc64: Unroll ECB decryption loops in AES driver. · 30101315
      David S. Miller 提交于
      Before:
      
      testing speed of ecb(aes) decryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 223 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 230 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 325 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 719 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 4266 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 211 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 234 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 353 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 808 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 5344 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 214 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 243 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 393 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 939 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 6039 cycles (8192 bytes)
      
      After:
      
      testing speed of ecb(aes) decryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 226 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 231 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 313 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 681 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 3964 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 205 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 240 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 341 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 770 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 5050 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 216 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 250 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 371 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 869 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 5494 cycles (8192 bytes)
      Signed-off-by: NDavid S. Miller <davem@davemloft.net>
      30101315
    • D
      sparc64: Unroll ECB encryption loops in AES driver. · 03d168ad
      David S. Miller 提交于
      The AES opcodes have a 3 cycle latency, so by doing 32-bytes at a
      time we avoid a pipeline bubble in between every round.
      
      For the 256-bit key case, it looks like we're doing more work in
      order to reload the KEY registers during the loop to make space
      for scarce temporaries.  But the load dual issues with the AES
      operations so we get the KEY reloads essentially for free.
      
      Before:
      
      testing speed of ecb(aes) encryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 264 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 231 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 329 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 715 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 4248 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 221 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 234 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 359 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 803 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 5366 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 209 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 255 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 379 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 938 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 6041 cycles (8192 bytes)
      
      After:
      
      testing speed of ecb(aes) encryption
      test 0 (128 bit key, 16 byte blocks): 1 operation in 266 cycles (16 bytes)
      test 1 (128 bit key, 64 byte blocks): 1 operation in 256 cycles (64 bytes)
      test 2 (128 bit key, 256 byte blocks): 1 operation in 305 cycles (256 bytes)
      test 3 (128 bit key, 1024 byte blocks): 1 operation in 676 cycles (1024 bytes)
      test 4 (128 bit key, 8192 byte blocks): 1 operation in 3981 cycles (8192 bytes)
      test 5 (192 bit key, 16 byte blocks): 1 operation in 210 cycles (16 bytes)
      test 6 (192 bit key, 64 byte blocks): 1 operation in 233 cycles (64 bytes)
      test 7 (192 bit key, 256 byte blocks): 1 operation in 340 cycles (256 bytes)
      test 8 (192 bit key, 1024 byte blocks): 1 operation in 766 cycles (1024 bytes)
      test 9 (192 bit key, 8192 byte blocks): 1 operation in 5136 cycles (8192 bytes)
      test 10 (256 bit key, 16 byte blocks): 1 operation in 206 cycles (16 bytes)
      test 11 (256 bit key, 64 byte blocks): 1 operation in 268 cycles (64 bytes)
      test 12 (256 bit key, 256 byte blocks): 1 operation in 368 cycles (256 bytes)
      test 13 (256 bit key, 1024 byte blocks): 1 operation in 890 cycles (1024 bytes)
      test 14 (256 bit key, 8192 byte blocks): 1 operation in 5718 cycles (8192 bytes)
      Signed-off-by: NDavid S. Miller <davem@davemloft.net>
      03d168ad
    • D
      9fd130ec
    • D
      sparc64: Move AES driver over to a methods based implementation. · 0bdcaf74
      David S. Miller 提交于
      Instead of testing and branching off of the key size on every
      encrypt/decrypt call, use method ops assigned at key set time.
      
      Reverse the order of float registers used for decryption to make
      future changes easier.
      
      Align all assembler routines on a 32-byte boundary.
      Signed-off-by: NDavid S. Miller <davem@davemloft.net>
      0bdcaf74
  4. 29 8月, 2012 3 次提交
  5. 26 8月, 2012 1 次提交
  6. 23 8月, 2012 2 次提交
  7. 21 8月, 2012 4 次提交
  8. 19 8月, 2012 20 次提交
  9. 18 8月, 2012 3 次提交
    • L
      Merge tag 'md-3.6-fixes' of git://neil.brown.name/md · 1ce41cd8
      Linus Torvalds 提交于
      Pull md fixes from NeilBrown:
       "2 fixes for md, tagged for -stable"
      
      * tag 'md-3.6-fixes' of git://neil.brown.name/md:
        md/raid10: fix problem with on-stack allocation of r10bio structure.
        md: Don't truncate size at 4TB for RAID0 and Linear
      1ce41cd8
    • N
      md/raid10: fix problem with on-stack allocation of r10bio structure. · e0ee7785
      NeilBrown 提交于
      A 'struct r10bio' has an array of per-copy information at the end.
      This array is declared with size [0] and r10bio_pool_alloc allocates
      enough extra space to store the per-copy information depending on the
      number of copies needed.
      
      So declaring a 'struct r10bio on the stack isn't going to work.  It
      won't allocate enough space, and memory corruption will ensue.
      
      So in the two places where this is done, declare a sufficiently large
      structure and use that instead.
      
      The two call-sites of this bug were introduced in 3.4 and 3.5
      so this is suitable for both those kernels.  The patch will have to
      be modified for 3.4 as it only has one bug.
      
      Cc: stable@vger.kernel.org
      Reported-by: NIvan Vasilyev <ivan.vasilyev@gmail.com>
      Tested-by: NIvan Vasilyev <ivan.vasilyev@gmail.com>
      Signed-off-by: NNeilBrown <neilb@suse.de>
      e0ee7785
    • L
      Merge tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband · 846b9996
      Linus Torvalds 提交于
      Pull infiniband/rdma fixes from Roland Dreier:
       "Grab bag of InfiniBand/RDMA fixes:
         - IPoIB fixes for regressions introduced by path database conversion
         - mlx4 fixes for bugs with large memory systems and regressions from
           SR-IOV patches
         - RDMA CM fix for passing bad event up to userspace
         - Other minor fixes"
      
      * tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband:
        IB/mlx4: Check iboe netdev pointer before dereferencing it
        mlx4_core: Clean up buddy bitmap allocation
        mlx4_core: Fix integer overflow issues around MTT table
        mlx4_core: Allow large mlx4_buddy bitmaps
        IB/srp: Fix a race condition
        IB/qib: Fix error return code in qib_init_7322_variables()
        IB: Fix typos in infiniband drivers
        IB/ipoib: Fix RCU pointer dereference of wrong object
        IB/ipoib: Add missing locking when CM object is deleted
        RDMA/ucma.c: Fix for events with wrong context on iWARP
        RDMA/ocrdma: Don't call vlan_dev_real_dev() for non-VLAN netdevs
        IB/mlx4: Fix possible deadlock on sm_lock spinlock
      846b9996