1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
6 * This file is part of Lustre, http://www.sf.net/projects/lustre/
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.
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.
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.
25 #include <linux/module.h>
26 #include <linux/miscdevice.h>
28 #define DEBUG_SUBSYSTEM S_MDC
30 #include <linux/lustre_mds.h>
31 #include <linux/lustre_lite.h>
33 #define REQUEST_MINOR 244
35 extern int mds_queue_req(struct ptlrpc_request *);
37 int mdc_connect(struct ptlrpc_client *cl, struct ptlrpc_connection *conn,
38 struct ll_fid *rootfid, struct ptlrpc_request **request)
40 struct ptlrpc_request *req;
41 struct mds_body *body;
42 int rc, size = sizeof(*body);
45 req = ptlrpc_prep_req(cl, conn, MDS_CONNECT, 1, &size, NULL);
47 GOTO(out, rc = -ENOMEM);
49 body = lustre_msg_buf(req->rq_reqmsg, 0);
50 req->rq_replen = lustre_msg_size(1, &size);
52 mds_pack_req_body(req);
53 rc = ptlrpc_queue_wait(req);
54 rc = ptlrpc_check_status(req, rc);
57 mds_unpack_rep_body(req);
58 body = lustre_msg_buf(req->rq_repmsg, 0);
59 memcpy(rootfid, &body->fid1, sizeof(*rootfid));
61 CDEBUG(D_NET, "root ino: %Ld\n", rootfid->id);
72 int mdc_getattr(struct ptlrpc_client *cl, struct ptlrpc_connection *conn,
73 ino_t ino, int type, unsigned long valid,
74 struct ptlrpc_request **request)
76 struct ptlrpc_request *req;
77 struct mds_body *body;
78 int rc, size = sizeof(*body);
81 req = ptlrpc_prep_req(cl, conn, MDS_GETATTR, 1, &size, NULL);
83 GOTO(out, rc = -ENOMEM);
85 body = lustre_msg_buf(req->rq_reqmsg, 0);
86 ll_ino2fid(&body->fid1, ino, 0, type);
89 req->rq_replen = lustre_msg_size(1, &size);
91 rc = ptlrpc_queue_wait(req);
92 rc = ptlrpc_check_status(req, rc);
95 mds_unpack_rep_body(req);
96 body = lustre_msg_buf(req->rq_repmsg, 0);
97 CDEBUG(D_NET, "mode: %o\n", body->mode);
106 int mdc_open(struct ptlrpc_client *cl, struct ptlrpc_connection *conn,
107 ino_t ino, int type, int flags, __u64 *fh,
108 struct ptlrpc_request **request)
110 struct mds_body *body;
111 int rc, size = sizeof(*body);
112 struct ptlrpc_request *req;
114 req = ptlrpc_prep_req(cl, conn, MDS_OPEN, 1, &size, NULL);
116 GOTO(out, rc = -ENOMEM);
118 body = lustre_msg_buf(req->rq_reqmsg, 0);
119 ll_ino2fid(&body->fid1, ino, 0, type);
120 body->flags = HTON__u32(flags);
122 req->rq_replen = lustre_msg_size(1, &size);
124 rc = ptlrpc_queue_wait(req);
125 rc = ptlrpc_check_status(req, rc);
128 mds_unpack_rep_body(req);
129 body = lustre_msg_buf(req->rq_repmsg, 0);
139 int mdc_close(struct ptlrpc_client *cl, struct ptlrpc_connection *conn,
140 ino_t ino, int type, __u64 fh, struct ptlrpc_request **request)
142 struct mds_body *body;
143 int rc, size = sizeof(*body);
144 struct ptlrpc_request *req;
146 req = ptlrpc_prep_req(cl, conn, MDS_CLOSE, 1, &size, NULL);
148 GOTO(out, rc = -ENOMEM);
150 body = lustre_msg_buf(req->rq_reqmsg, 0);
151 ll_ino2fid(&body->fid1, ino, 0, type);
154 req->rq_replen = lustre_msg_size(1, &size);
156 rc = ptlrpc_queue_wait(req);
157 rc = ptlrpc_check_status(req, rc);
165 int mdc_readpage(struct ptlrpc_client *cl, struct ptlrpc_connection *conn,
166 ino_t ino, int type, __u64 offset, char *addr,
167 struct ptlrpc_request **request)
169 struct ptlrpc_request *req = NULL;
170 struct ptlrpc_bulk_desc *bulk = NULL;
171 struct niobuf niobuf;
172 struct mds_body *body;
173 int rc, size[2] = {sizeof(*body), sizeof(struct niobuf)};
174 char *bufs[2] = {NULL, (char *)&niobuf};
176 niobuf.addr = (__u64) (long) addr;
178 CDEBUG(D_INODE, "inode: %ld\n", (long)ino);
180 bulk = ptlrpc_prep_bulk(conn);
182 CERROR("%s: cannot init bulk desc\n", __FUNCTION__);
187 req = ptlrpc_prep_req(cl, conn, MDS_READPAGE, 2, size, bufs);
189 GOTO(out, rc = -ENOMEM);
191 bulk->b_buflen = PAGE_SIZE;
192 bulk->b_buf = (void *)(long)niobuf.addr;
193 bulk->b_portal = MDS_BULK_PORTAL;
194 bulk->b_xid = req->rq_reqmsg->xid;
196 rc = ptlrpc_register_bulk(bulk);
198 CERROR("couldn't setup bulk sink: error %d.\n", rc);
202 body = lustre_msg_buf(req->rq_reqmsg, 0);
204 body->fid1.f_type = type;
207 req->rq_replen = lustre_msg_size(1, size);
209 rc = ptlrpc_queue_wait(req);
211 CERROR("error in handling %d\n", rc);
212 ptlrpc_abort_bulk(bulk);
216 mds_unpack_rep_body(req);
221 ptlrpc_free_bulk(bulk);
225 static int request_ioctl(struct inode *inode, struct file *file,
226 unsigned int cmd, unsigned long arg)
229 struct ptlrpc_client cl;
230 struct ptlrpc_connection *conn;
231 struct ptlrpc_request *request;
235 if (MINOR(inode->i_rdev) != REQUEST_MINOR)
238 if (_IOC_TYPE(cmd) != IOC_REQUEST_TYPE ||
239 _IOC_NR(cmd) < IOC_REQUEST_MIN_NR ||
240 _IOC_NR(cmd) > IOC_REQUEST_MAX_NR ) {
241 CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
242 _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
246 ptlrpc_init_client(NULL, MDS_REQUEST_PORTAL, MDC_REPLY_PORTAL, &cl);
247 conn = ptlrpc_uuid_to_connection("mds");
249 CERROR("cannot create client\n");
254 case IOC_REQUEST_GETATTR: {
255 CERROR("-- getting attr for ino %lu\n", arg);
256 err = mdc_getattr(&cl, conn, arg, S_IFDIR, ~0, &request);
257 CERROR("-- done err %d\n", err);
262 case IOC_REQUEST_READPAGE: {
264 OBD_ALLOC(buf, PAGE_SIZE);
269 CERROR("-- readpage 0 for ino %lu\n", arg);
270 err = mdc_readpage(&cl, conn, arg, S_IFDIR, 0, buf, &request);
271 CERROR("-- done err %d\n", err);
272 OBD_FREE(buf, PAGE_SIZE);
277 case IOC_REQUEST_SETATTR: {
282 inode.i_generation = 0;
283 iattr.ia_mode = 040777;
285 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
287 err = mdc_setattr(&cl, conn, &inode, &iattr, &request);
288 CERROR("-- done err %d\n", err);
293 case IOC_REQUEST_CREATE: {
298 inode.i_generation = 0;
299 iattr.ia_mode = 040777;
301 iattr.ia_valid = ATTR_MODE | ATTR_ATIME;
303 err = mdc_create(&cl, conn, &inode,
304 "foofile", strlen("foofile"),
305 NULL, 0, 0100707, 47114711,
306 11, 47, 0, &request);
307 CERROR("-- done err %d\n", err);
312 case IOC_REQUEST_OPEN: {
314 copy_from_user(&ino, (__u64 *)arg, sizeof(ino));
315 CERROR("-- opening ino %llu\n", (unsigned long long)ino);
316 err = mdc_open(&cl, conn, ino, S_IFDIR, O_RDONLY, &fh,
318 copy_to_user((__u64 *)arg, &fh, sizeof(fh));
319 CERROR("-- done err %d (fh=%Lu)\n", err,
320 (unsigned long long)fh);
325 case IOC_REQUEST_CLOSE: {
326 CERROR("-- closing ino 2, filehandle %lu\n", arg);
327 err = mdc_close(&cl, conn, 2, S_IFDIR, arg, &request);
328 CERROR("-- done err %d\n", err);
334 GOTO(out, err = -EINVAL);
338 ptlrpc_free_req(request);
339 ptlrpc_put_connection(conn);
345 static struct file_operations requestdev_fops = {
346 ioctl: request_ioctl,
349 static struct miscdevice request_dev = {
355 static int __init ptlrpc_request_init(void)
357 misc_register(&request_dev);
361 static void __exit ptlrpc_request_exit(void)
363 misc_deregister(&request_dev);
366 MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
367 MODULE_DESCRIPTION("Lustre MDS Request Tester v1.0");
368 MODULE_LICENSE("GPL");
370 EXPORT_SYMBOL(mdc_connect);
371 EXPORT_SYMBOL(mdc_getattr);
372 EXPORT_SYMBOL(mdc_create);
373 EXPORT_SYMBOL(mdc_unlink);
374 EXPORT_SYMBOL(mdc_rename);
375 EXPORT_SYMBOL(mdc_link);
376 EXPORT_SYMBOL(mdc_readpage);
377 EXPORT_SYMBOL(mdc_setattr);
378 EXPORT_SYMBOL(mdc_close);
379 EXPORT_SYMBOL(mdc_open);
381 module_init(ptlrpc_request_init);
382 module_exit(ptlrpc_request_exit);