1. 30 10月, 2011 1 次提交
    • N
      [SCSI] mpt2sas: New feature - Fast Load Support · 921cd802
      nagalakshmi.nandigama@lsi.com 提交于
      New feature Fast Load Support.
      
      (1)Asynchronous SCSI scanning: This will allow the drivers to scan
      for devices in parallel while other device drivers are loading at
      the same time. This will improve the amount of time it takes for the
      OS to load.
      
      (2) Reporting Devices while port enable is active: This feature will
      allow devices to be reported to OS immediately while port enable is
      active. The previous implementation waits for port enable to complete,
      and then report devices. This feature is only enabled on IT firmware
      configurations when there are no boot device configured in BIOS Configuration
      Utility, else the driver will wait till port enable completes reporting
      devices. For IR firmware, this feature is turned off. This feature is to
      address large SAS topologies (>100 drives) when the boot OS is using onboard
      SATA device, in other words, the boot devices is not
      connected to our controller.
      
      (3) Scanning for devices after diagnostic reset completes: A new routine
      _scsih_scan_start is added. This will scan the expander pages, IR pages,
      and sas device pages, then reporting new devices to SCSI Mid layer. It
      seems the driver is not supporting adding devices while diagnostic reset
      is active. Apparently this is due to the sanity checks on
      ioc->shost_recovery flag throughout the context of kernel work thread FIFO,
      and the mpt2sas_fw_work.
      Signed-off-by: NNagalakshmi Nandigama <nagalakshmi.nandigama@lsi.com>
      Signed-off-by: NJames Bottomley <JBottomley@Parallels.com>
      921cd802
  2. 22 9月, 2011 1 次提交
    • N
      [SCSI] mpt2sas: Added NUNA IO support in driver which uses multi-reply queue support of the HBA · 911ae943
      nagalakshmi.nandigama@lsi.com 提交于
      Support added for controllers capable of multi reply queues.
      
      The following are the modifications to the driver to support NUMA.
      
      1) Create the new structure adapter_reply_queue to contain the reply queue
         info for every msix vector.  This object will contain a
         reply_post_host_index, reply_post_free for each instance, msix_index, among
         other parameters.  We will track all the reply queues on a link list called
         ioc->reply_queue_list. Each reply queue is aligned with each IRQ, and is
         passed to the interrupt via the bus_id parameter.
      
      (2) The driver will figure out the msix_vector_count from the PCIe MSIX
          capabilities register instead of the IOC Facts->MaxMSIxVectors. This is
          because the firmware is not filling in this field until the driver has
          already registered MSIX support.
      
      (3) If the ioc_facts reports that the controller is MSIX compatible in the
          capabilities, then the driver will request for multiple irqs.  This count
          is calculated based on the minimum between the online cpus available and
          the ioc->msix_vector_count.  This count is reported to firmware in the
          ioc_init request.
      
      (4) New routines were added _base_free_irq and _base_request_irq, so
          registering and freeing msix vectors were done thru simple function API.
      
      (5) The new routine _base_assign_reply_queues was added to align the msix
          indexes across cpus. This will initialize the array called
          ioc->cpu_msix_table.  This array is looked up on every MPI request so the
          MSIxIndex is set appropriately.
      
      (6) A new shost sysfs attribute was added to report the reply_queue_count.
      
      (7) User needs to set the affinity cpu mask, so the interrupts occur on the
          same cpu that sent the original request.
      Signed-off-by: NNagalakshmi Nandigama <nagalakshmi.nandigama@lsi.com>
      Signed-off-by: NJames Bottomley <JBottomley@Parallels.com>
      911ae943
  3. 15 9月, 2011 1 次提交
  4. 30 6月, 2011 2 次提交
  5. 01 5月, 2011 1 次提交
    • K
      [SCSI] mpt2sas : WarpDrive New product SSS6200 support added · 0bdccdb0
      Kashyap, Desai 提交于
      This patch has Support for the new solid state device product SSS6200
      from LSI and relavent features w.r.t SSS6200.
      
      The major feature added in this driver is supporting Direct-I/O to the
      SSS6200 storage.There are some additional changes done to avoid exposing
      the RAID member disks to the OS and hiding/exposing drives based on the
      OEM Specific Flag in Manufacturing Page10 (this is required to handle
      specific changes in the SSS6200 firmware).
      
      Each and every changes are listed below.
      1. Hiding IR related messages.
      For SSS6200, the driver is modified not to print IR related events.
      Even if the debugging is enabled the IR related messages will not be displayed.
      In some places if there is a need to display a message related to IR the
      string "IR" is replaced with string "DD" and the string "volume" is replaced
      with "direct drive". But the function names are not changed hence there are
      some places where the reference to volume can be seen if debug level is set.
      
      2. Removed RAID transport support
      In Linux the user can retrieve RAID volume information from the sysfs directory.
      This support is removed for SSS6200.
      
      3. Direct I/O support.
      The driver tries to enable direct I/O when a volume is reported to the driver
      by the firmware through IRCC events and the driver does this just before
      reporting to the OS, hence all the OS issued I/O can go through direct path
      if they can, The first validation is to see whether the manufacturing page10
      flag is set to expose all drives always. If that is set, the driver will not
      enable direct I/O and displays the message "DDIO" is disabled globally as
      drives are exposed. The driver checks whether there is more than one volume
      in the controller, if so the direct I/O will be disabled globally for all
      volumes in the controller and the message displayed will be "DDIO is disabled
      globally as number of drives > 1.
      If retrieving number of PD is failed the driver will not enable direct I/O
      and displays the message Failure in computing number of drives DDIO disabled.
      If memory allocation for RAIDVolumePage0 is failed, the driver will not enable
      direct I/O and displays the message Memory allocation failure for
      RVPG0 DDIO disabled.  If retrieving RAIDVolumePage0 is failed the driver will
      not enable direct I/O and displays the message Failure in retrieving
      RVPG0 DDIO disabled
      
      If the number of PD in a volume is greater than 8, then the direct I/O will
      be disabled.
      If any of individual drives handle retrieval is failed then the DD-IO will
      be disabled.
      If the volume is not RAID0 or if the block size is not 512 then the DD-IO will
      be disabled.
      If the volume size is greater than 2TB then the DD-IO will be disabled.
      If the driver is not able to find a valid stripe exponent using the configured
      stripe size then the DD-IO will be disabled
      
      When the DD-IO is enabled the driver will check every I/O request issued to
      the storage and checks whether the request is either
      READ6/WRITE6/READ10/WRITE10, if it is and if the complete I/O transfer
      is within a stripe size then the I/O is redirected to
      the drive directly instead of the volume.
      
      On completion of every I/O, if the completion is failure means if the reply
      is address reply with a reply frame associated with it, then the type of I/O
      will be checked, if the I/O is direct then the I/O will be retried to
      the volume once.
      Signed-off-by: NKashyap Desai <kashyap.desai@lsi.com>
      Reviewed-by: NEric Moore <eric.moore@lsi.com>
      Reviewed-by: NSathya Prakash <sathya.prakash@lsi.com>
      Signed-off-by: NJames Bottomley <James.Bottomley@suse.de>
      0bdccdb0
  6. 25 4月, 2011 1 次提交
  7. 31 3月, 2011 1 次提交
  8. 22 12月, 2010 1 次提交
  9. 15 10月, 2010 1 次提交
    • A
      llseek: automatically add .llseek fop · 6038f373
      Arnd Bergmann 提交于
      All file_operations should get a .llseek operation so we can make
      nonseekable_open the default for future file operations without a
      .llseek pointer.
      
      The three cases that we can automatically detect are no_llseek, seq_lseek
      and default_llseek. For cases where we can we can automatically prove that
      the file offset is always ignored, we use noop_llseek, which maintains
      the current behavior of not returning an error from a seek.
      
      New drivers should normally not use noop_llseek but instead use no_llseek
      and call nonseekable_open at open time.  Existing drivers can be converted
      to do the same when the maintainer knows for certain that no user code
      relies on calling seek on the device file.
      
      The generated code is often incorrectly indented and right now contains
      comments that clarify for each added line why a specific variant was
      chosen. In the version that gets submitted upstream, the comments will
      be gone and I will manually fix the indentation, because there does not
      seem to be a way to do that using coccinelle.
      
      Some amount of new code is currently sitting in linux-next that should get
      the same modifications, which I will do at the end of the merge window.
      
      Many thanks to Julia Lawall for helping me learn to write a semantic
      patch that does all this.
      
      ===== begin semantic patch =====
      // This adds an llseek= method to all file operations,
      // as a preparation for making no_llseek the default.
      //
      // The rules are
      // - use no_llseek explicitly if we do nonseekable_open
      // - use seq_lseek for sequential files
      // - use default_llseek if we know we access f_pos
      // - use noop_llseek if we know we don't access f_pos,
      //   but we still want to allow users to call lseek
      //
      @ open1 exists @
      identifier nested_open;
      @@
      nested_open(...)
      {
      <+...
      nonseekable_open(...)
      ...+>
      }
      
      @ open exists@
      identifier open_f;
      identifier i, f;
      identifier open1.nested_open;
      @@
      int open_f(struct inode *i, struct file *f)
      {
      <+...
      (
      nonseekable_open(...)
      |
      nested_open(...)
      )
      ...+>
      }
      
      @ read disable optional_qualifier exists @
      identifier read_f;
      identifier f, p, s, off;
      type ssize_t, size_t, loff_t;
      expression E;
      identifier func;
      @@
      ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
      {
      <+...
      (
         *off = E
      |
         *off += E
      |
         func(..., off, ...)
      |
         E = *off
      )
      ...+>
      }
      
      @ read_no_fpos disable optional_qualifier exists @
      identifier read_f;
      identifier f, p, s, off;
      type ssize_t, size_t, loff_t;
      @@
      ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
      {
      ... when != off
      }
      
      @ write @
      identifier write_f;
      identifier f, p, s, off;
      type ssize_t, size_t, loff_t;
      expression E;
      identifier func;
      @@
      ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
      {
      <+...
      (
        *off = E
      |
        *off += E
      |
        func(..., off, ...)
      |
        E = *off
      )
      ...+>
      }
      
      @ write_no_fpos @
      identifier write_f;
      identifier f, p, s, off;
      type ssize_t, size_t, loff_t;
      @@
      ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
      {
      ... when != off
      }
      
      @ fops0 @
      identifier fops;
      @@
      struct file_operations fops = {
       ...
      };
      
      @ has_llseek depends on fops0 @
      identifier fops0.fops;
      identifier llseek_f;
      @@
      struct file_operations fops = {
      ...
       .llseek = llseek_f,
      ...
      };
      
      @ has_read depends on fops0 @
      identifier fops0.fops;
      identifier read_f;
      @@
      struct file_operations fops = {
      ...
       .read = read_f,
      ...
      };
      
      @ has_write depends on fops0 @
      identifier fops0.fops;
      identifier write_f;
      @@
      struct file_operations fops = {
      ...
       .write = write_f,
      ...
      };
      
      @ has_open depends on fops0 @
      identifier fops0.fops;
      identifier open_f;
      @@
      struct file_operations fops = {
      ...
       .open = open_f,
      ...
      };
      
      // use no_llseek if we call nonseekable_open
      ////////////////////////////////////////////
      @ nonseekable1 depends on !has_llseek && has_open @
      identifier fops0.fops;
      identifier nso ~= "nonseekable_open";
      @@
      struct file_operations fops = {
      ...  .open = nso, ...
      +.llseek = no_llseek, /* nonseekable */
      };
      
      @ nonseekable2 depends on !has_llseek @
      identifier fops0.fops;
      identifier open.open_f;
      @@
      struct file_operations fops = {
      ...  .open = open_f, ...
      +.llseek = no_llseek, /* open uses nonseekable */
      };
      
      // use seq_lseek for sequential files
      /////////////////////////////////////
      @ seq depends on !has_llseek @
      identifier fops0.fops;
      identifier sr ~= "seq_read";
      @@
      struct file_operations fops = {
      ...  .read = sr, ...
      +.llseek = seq_lseek, /* we have seq_read */
      };
      
      // use default_llseek if there is a readdir
      ///////////////////////////////////////////
      @ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      identifier readdir_e;
      @@
      // any other fop is used that changes pos
      struct file_operations fops = {
      ... .readdir = readdir_e, ...
      +.llseek = default_llseek, /* readdir is present */
      };
      
      // use default_llseek if at least one of read/write touches f_pos
      /////////////////////////////////////////////////////////////////
      @ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      identifier read.read_f;
      @@
      // read fops use offset
      struct file_operations fops = {
      ... .read = read_f, ...
      +.llseek = default_llseek, /* read accesses f_pos */
      };
      
      @ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      identifier write.write_f;
      @@
      // write fops use offset
      struct file_operations fops = {
      ... .write = write_f, ...
      +	.llseek = default_llseek, /* write accesses f_pos */
      };
      
      // Use noop_llseek if neither read nor write accesses f_pos
      ///////////////////////////////////////////////////////////
      
      @ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      identifier read_no_fpos.read_f;
      identifier write_no_fpos.write_f;
      @@
      // write fops use offset
      struct file_operations fops = {
      ...
       .write = write_f,
       .read = read_f,
      ...
      +.llseek = noop_llseek, /* read and write both use no f_pos */
      };
      
      @ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      identifier write_no_fpos.write_f;
      @@
      struct file_operations fops = {
      ... .write = write_f, ...
      +.llseek = noop_llseek, /* write uses no f_pos */
      };
      
      @ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      identifier read_no_fpos.read_f;
      @@
      struct file_operations fops = {
      ... .read = read_f, ...
      +.llseek = noop_llseek, /* read uses no f_pos */
      };
      
      @ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
      identifier fops0.fops;
      @@
      struct file_operations fops = {
      ...
      +.llseek = noop_llseek, /* no read or write fn */
      };
      ===== End semantic patch =====
      Signed-off-by: NArnd Bergmann <arnd@arndb.de>
      Cc: Julia Lawall <julia@diku.dk>
      Cc: Christoph Hellwig <hch@infradead.org>
      6038f373
  10. 16 9月, 2010 1 次提交
    • A
      scsi: autoconvert trivial BKL users to private mutex · c45d15d2
      Arnd Bergmann 提交于
      All these files use the big kernel lock in a trivial
      way to serialize their private file operations,
      typically resulting from an earlier semi-automatic
      pushdown from VFS.
      
      None of these drivers appears to want to lock against
      other code, and they all use the BKL as the top-level
      lock in their file operations, meaning that there
      is no lock-order inversion problem.
      
      Consequently, we can remove the BKL completely,
      replacing it with a per-file mutex in every case.
      Using a scripted approach means we can avoid
      typos.
      
      file=$1
      name=$2
      if grep -q lock_kernel ${file} ; then
          if grep -q 'include.*linux.mutex.h' ${file} ; then
                  sed -i '/include.*<linux\/smp_lock.h>/d' ${file}
          else
                  sed -i 's/include.*<linux\/smp_lock.h>.*$/include <linux\/mutex.h>/g' ${file}
          fi
          sed -i ${file} \
              -e "/^#include.*linux.mutex.h/,$ {
                      1,/^\(static\|int\|long\)/ {
                           /^\(static\|int\|long\)/istatic DEFINE_MUTEX(${name}_mutex);
      
      } }"  \
          -e "s/\(un\)*lock_kernel\>[ ]*()/mutex_\1lock(\&${name}_mutex)/g" \
          -e '/[      ]*cycle_kernel_lock();/d'
      else
          sed -i -e '/include.*\<smp_lock.h\>/d' ${file}  \
                      -e '/cycle_kernel_lock()/d'
      fi
      Signed-off-by: NArnd Bergmann <arnd@arndb.de>
      Cc: linux-scsi@vger.kernel.org
      Cc: "James E.J. Bottomley" <James.Bottomley@suse.de>
      c45d15d2
  11. 28 7月, 2010 7 次提交
  12. 12 4月, 2010 1 次提交
  13. 11 4月, 2010 3 次提交
  14. 09 2月, 2010 2 次提交
  15. 30 10月, 2009 5 次提交
  16. 02 10月, 2009 5 次提交
  17. 05 9月, 2009 1 次提交
  18. 24 5月, 2009 1 次提交
  19. 27 4月, 2009 3 次提交
  20. 18 3月, 2009 1 次提交