← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/scsi/scsi_transport_iscsi.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/scsi/scsi_transport_iscsi.c
954
954
        if (dd_size)
955
955
                conn->dd_data = &conn[1];
956
956
 
 
957
        mutex_init(&conn->ep_mutex);
957
958
        INIT_LIST_HEAD(&conn->conn_list);
958
959
        conn->transport = transport;
959
960
        conn->cid = cid;
975
976
 
976
977
        spin_lock_irqsave(&connlock, flags);
977
978
        list_add(&conn->conn_list, &connlist);
978
 
        conn->active = 1;
979
979
        spin_unlock_irqrestore(&connlock, flags);
980
980
 
981
981
        ISCSI_DBG_TRANS_CONN(conn, "Completed conn creation\n");
1001
1001
        unsigned long flags;
1002
1002
 
1003
1003
        spin_lock_irqsave(&connlock, flags);
1004
 
        conn->active = 0;
1005
1004
        list_del(&conn->conn_list);
1006
1005
        spin_unlock_irqrestore(&connlock, flags);
1007
1006
 
1430
1429
        return err;
1431
1430
}
1432
1431
 
 
1432
static int iscsi_if_ep_disconnect(struct iscsi_transport *transport,
 
1433
                                  u64 ep_handle)
 
1434
{
 
1435
        struct iscsi_cls_conn *conn;
 
1436
        struct iscsi_endpoint *ep;
 
1437
 
 
1438
        if (!transport->ep_disconnect)
 
1439
                return -EINVAL;
 
1440
 
 
1441
        ep = iscsi_lookup_endpoint(ep_handle);
 
1442
        if (!ep)
 
1443
                return -EINVAL;
 
1444
        conn = ep->conn;
 
1445
        if (conn) {
 
1446
                mutex_lock(&conn->ep_mutex);
 
1447
                conn->ep = NULL;
 
1448
                mutex_unlock(&conn->ep_mutex);
 
1449
        }
 
1450
 
 
1451
        transport->ep_disconnect(ep);
 
1452
        return 0;
 
1453
}
 
1454
 
1433
1455
static int
1434
1456
iscsi_if_transport_ep(struct iscsi_transport *transport,
1435
1457
                      struct iscsi_uevent *ev, int msg_type)
1454
1476
                                                   ev->u.ep_poll.timeout_ms);
1455
1477
                break;
1456
1478
        case ISCSI_UEVENT_TRANSPORT_EP_DISCONNECT:
1457
 
                if (!transport->ep_disconnect)
1458
 
                        return -EINVAL;
1459
 
 
1460
 
                ep = iscsi_lookup_endpoint(ev->u.ep_disconnect.ep_handle);
1461
 
                if (!ep)
1462
 
                        return -EINVAL;
1463
 
 
1464
 
                transport->ep_disconnect(ep);
 
1479
                rc = iscsi_if_ep_disconnect(transport,
 
1480
                                            ev->u.ep_disconnect.ep_handle);
1465
1481
                break;
1466
1482
        }
1467
1483
        return rc;
1609
1625
                session = iscsi_session_lookup(ev->u.b_conn.sid);
1610
1626
                conn = iscsi_conn_lookup(ev->u.b_conn.sid, ev->u.b_conn.cid);
1611
1627
 
1612
 
                if (session && conn)
1613
 
                        ev->r.retcode = transport->bind_conn(session, conn,
1614
 
                                        ev->u.b_conn.transport_eph,
1615
 
                                        ev->u.b_conn.is_leading);
1616
 
                else
 
1628
                if (conn && conn->ep)
 
1629
                        iscsi_if_ep_disconnect(transport, conn->ep->id);
 
1630
 
 
1631
                if (!session || !conn) {
1617
1632
                        err = -EINVAL;
 
1633
                        break;
 
1634
                }
 
1635
 
 
1636
                ev->r.retcode = transport->bind_conn(session, conn,
 
1637
                                                ev->u.b_conn.transport_eph,
 
1638
                                                ev->u.b_conn.is_leading);
 
1639
                if (ev->r.retcode || !transport->ep_connect)
 
1640
                        break;
 
1641
 
 
1642
                ep = iscsi_lookup_endpoint(ev->u.b_conn.transport_eph);
 
1643
                if (ep) {
 
1644
                        ep->conn = conn;
 
1645
 
 
1646
                        mutex_lock(&conn->ep_mutex);
 
1647
                        conn->ep = ep;
 
1648
                        mutex_unlock(&conn->ep_mutex);
 
1649
                } else
 
1650
                        iscsi_cls_conn_printk(KERN_ERR, conn,
 
1651
                                              "Could not set ep conn "
 
1652
                                              "binding\n");
1618
1653
                break;
1619
1654
        case ISCSI_UEVENT_SET_PARAM:
1620
1655
                err = iscsi_set_param(transport, ev);
1747
1782
iscsi_conn_attr(ifmarker, ISCSI_PARAM_IFMARKER_EN);
1748
1783
iscsi_conn_attr(ofmarker, ISCSI_PARAM_OFMARKER_EN);
1749
1784
iscsi_conn_attr(persistent_port, ISCSI_PARAM_PERSISTENT_PORT);
1750
 
iscsi_conn_attr(port, ISCSI_PARAM_CONN_PORT);
1751
1785
iscsi_conn_attr(exp_statsn, ISCSI_PARAM_EXP_STATSN);
1752
1786
iscsi_conn_attr(persistent_address, ISCSI_PARAM_PERSISTENT_ADDRESS);
1753
 
iscsi_conn_attr(address, ISCSI_PARAM_CONN_ADDRESS);
1754
1787
iscsi_conn_attr(ping_tmo, ISCSI_PARAM_PING_TMO);
1755
1788
iscsi_conn_attr(recv_tmo, ISCSI_PARAM_RECV_TMO);
1756
1789
 
 
1790
#define iscsi_conn_ep_attr_show(param)                                  \
 
1791
static ssize_t show_conn_ep_param_##param(struct device *dev,           \
 
1792
                                          struct device_attribute *attr,\
 
1793
                                          char *buf)                    \
 
1794
{                                                                       \
 
1795
        struct iscsi_cls_conn *conn = iscsi_dev_to_conn(dev->parent);   \
 
1796
        struct iscsi_transport *t = conn->transport;                    \
 
1797
        struct iscsi_endpoint *ep;                                      \
 
1798
        ssize_t rc;                                                     \
 
1799
                                                                        \
 
1800
        /*                                                              \
 
1801
         * Need to make sure ep_disconnect does not free the LLD's      \
 
1802
         * interconnect resources while we are trying to read them.     \
 
1803
         */                                                             \
 
1804
        mutex_lock(&conn->ep_mutex);                                    \
 
1805
        ep = conn->ep;                                                  \
 
1806
        if (!ep && t->ep_connect) {                                     \
 
1807
                mutex_unlock(&conn->ep_mutex);                          \
 
1808
                return -ENOTCONN;                                       \
 
1809
        }                                                               \
 
1810
                                                                        \
 
1811
        if (ep)                                                         \
 
1812
                rc = t->get_ep_param(ep, param, buf);                   \
 
1813
        else                                                            \
 
1814
                rc = t->get_conn_param(conn, param, buf);               \
 
1815
        mutex_unlock(&conn->ep_mutex);                                  \
 
1816
        return rc;                                                      \
 
1817
}
 
1818
 
 
1819
#define iscsi_conn_ep_attr(field, param)                                \
 
1820
        iscsi_conn_ep_attr_show(param)                                  \
 
1821
static ISCSI_CLASS_ATTR(conn, field, S_IRUGO,                           \
 
1822
                        show_conn_ep_param_##param, NULL);
 
1823
 
 
1824
iscsi_conn_ep_attr(address, ISCSI_PARAM_CONN_ADDRESS);
 
1825
iscsi_conn_ep_attr(port, ISCSI_PARAM_CONN_PORT);
 
1826
 
1757
1827
/*
1758
1828
 * iSCSI session attrs
1759
1829
 */