Whamcloud - gitweb
Landing the mds_lock_devel branch on the trunk. Notables:
[fs/lustre-release.git] / lustre / mdc / mdc_reint.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
5  *
6  *   This file is part of Lustre, http://www.sf.net/projects/lustre/
7  *
8  *   Lustre is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Lustre is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Lustre; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  */
22
23 #define EXPORT_SYMTAB
24
25 #include <linux/config.h>
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28
29 #define DEBUG_SUBSYSTEM S_MDC
30
31 #include <linux/obd_class.h>
32 #include <linux/lustre_mds.h>
33
34 static int mdc_reint(struct ptlrpc_request *request, int level)
35 {
36         int rc;
37         request->rq_level = level;
38
39         rc = ptlrpc_queue_wait(request);
40         rc = ptlrpc_check_status(request, rc);
41
42         if (rc)
43                 CERROR("error in handling %d\n", rc);
44
45         return rc;
46 }
47
48 int mdc_setattr(struct obd_conn *conn,
49                 struct inode *inode, struct iattr *iattr,
50                 struct ptlrpc_request **request)
51 {
52         struct mdc_obd *mdc = mdc_conn2mdc(conn);
53         struct mds_rec_setattr *rec;
54         struct ptlrpc_request *req;
55         int rc, size = sizeof(*rec);
56         ENTRY;
57
58         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, 
59                               MDS_REINT, 1, &size, NULL);
60         if (!req)
61                 RETURN(-ENOMEM);
62
63         mds_setattr_pack(req, 0, inode, iattr, NULL, 0);
64
65         size = sizeof(struct mds_body);
66         req->rq_replen = lustre_msg_size(1, &size);
67
68         rc = mdc_reint(req, LUSTRE_CONN_FULL);
69         *request = req;
70         if (rc == -ERESTARTSYS )
71                 rc = 0;
72
73         RETURN(rc);
74 }
75
76 int mdc_create(struct obd_conn *conn,
77                struct inode *dir, const char *name, int namelen,
78                const char *tgt, int tgtlen, int mode, __u32 uid,
79                __u32 gid, __u64 time, __u64 rdev, struct obdo *obdo,
80                struct ptlrpc_request **request)
81 {
82         struct mds_rec_create *rec;
83         struct mdc_obd *mdc = mdc_conn2mdc(conn);
84         struct ptlrpc_request *req;
85         int rc, size[3] = {sizeof(struct mds_rec_create), namelen + 1, 0};
86         char *tmp, *bufs[3] = {NULL, NULL, NULL};
87         int level, bufcount = 2;
88         ENTRY;
89
90         if (S_ISREG(mode)) {
91                 size[2] = sizeof(*obdo);
92                 bufs[2] = (char *)obdo;
93                 bufcount = 3;
94         } else if (S_ISLNK(mode)) {
95                 size[2] = tgtlen + 1;
96                 bufcount = 3;
97         }
98
99         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_REINT,
100                               bufcount, size, bufs);
101         if (!req)
102                 RETURN(-ENOMEM);
103
104         rec = lustre_msg_buf(req->rq_reqmsg, 0);
105         mds_create_pack(req, 0, dir, mode, rdev, uid, gid, time,
106                         name, namelen, NULL, 0);
107
108         if (S_ISREG(mode)) {
109                 tmp = lustre_msg_buf(req->rq_reqmsg, 2);
110                 memcpy(tmp, obdo, sizeof(*obdo));
111         } else if (S_ISLNK(mode)) {
112                 tmp = lustre_msg_buf(req->rq_reqmsg, 2);
113                 LOGL0(tgt, tgtlen, tmp);
114         }
115
116         size[0] = sizeof(struct mds_body);
117         req->rq_replen = lustre_msg_size(1, size);
118
119         level = LUSTRE_CONN_FULL;
120  resend:
121         rc = mdc_reint(req, level);
122         if (rc == -ERESTARTSYS) {
123                 struct mds_update_record_hdr *hdr =
124                         lustre_msg_buf(req->rq_reqmsg, 0);
125                 level = LUSTRE_CONN_RECOVD;
126                 CERROR("Lost reply: re-create rep.\n");
127                 req->rq_flags = 0;
128                 hdr->ur_opcode = NTOH__u32(REINT_RECREATE);
129                 goto resend;
130         }
131
132         *request = req;
133         RETURN(rc);
134 }
135
136 int mdc_unlink(struct obd_conn *conn,
137                struct inode *dir, struct inode *child, const char *name,
138                int namelen, struct ptlrpc_request **request)
139 {
140         struct mdc_obd *mdc = mdc_conn2mdc(conn);
141         struct ptlrpc_request *req;
142         int rc, size[2] = {sizeof(struct mds_rec_unlink), namelen + 1};
143         ENTRY;
144
145         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_REINT, 2,
146                               size, NULL);
147         if (!req)
148                 RETURN(-ENOMEM);
149
150         mds_unlink_pack(req, 0, dir, child, name, namelen);
151
152         size[0] = sizeof(struct mds_body);
153         req->rq_replen = lustre_msg_size(1, size);
154
155         rc = mdc_reint(req, LUSTRE_CONN_FULL);
156         *request = req;
157         if (rc == -ERESTARTSYS )
158                 rc = 0;
159
160         RETURN(rc);
161 }
162
163 int mdc_link(struct obd_conn *conn,
164              struct dentry *src, struct inode *dir, const char *name,
165              int namelen, struct ptlrpc_request **request)
166 {
167         struct mdc_obd *mdc = mdc_conn2mdc(conn);
168         struct ptlrpc_request *req;
169         int rc, size[2] = {sizeof(struct mds_rec_link), namelen + 1};
170         ENTRY;
171
172         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, MDS_REINT, 2,
173                               size, NULL);
174         if (!req)
175                 RETURN(-ENOMEM);
176
177         mds_link_pack(req, 0, src->d_inode, dir, name, namelen);
178
179         size[0] = sizeof(struct mds_body);
180         req->rq_replen = lustre_msg_size(1, size);
181
182         rc = mdc_reint(req, LUSTRE_CONN_FULL);
183         *request = req;
184         if (rc == -ERESTARTSYS )
185                 rc = 0;
186
187         RETURN(rc);
188 }
189
190 int mdc_rename(struct obd_conn *conn,
191                struct inode *src, struct inode *tgt, const char *old,
192                int oldlen, const char *new, int newlen,
193                struct ptlrpc_request **request)
194 {
195         struct mdc_obd *mdc = mdc_conn2mdc(conn);
196         struct ptlrpc_request *req;
197         int rc, size[3] = {sizeof(struct mds_rec_rename), oldlen + 1,
198                            newlen + 1};
199         ENTRY;
200
201         req = ptlrpc_prep_req(mdc->mdc_client, mdc->mdc_conn, 
202                               MDS_REINT, 3, size, NULL);
203         if (!req)
204                 RETURN(-ENOMEM);
205
206         mds_rename_pack(req, 0, src, tgt, old, oldlen, new, newlen);
207
208         size[0] = sizeof(struct mds_body);
209         req->rq_replen = lustre_msg_size(1, size);
210
211         rc = mdc_reint(req, LUSTRE_CONN_FULL);
212         *request = req;
213         if (rc == -ERESTARTSYS )
214                 rc = 0;
215
216         RETURN(rc);
217 }